← Back to branch summary

~ubuntu-branches/debian/sid/mame/sid

« back to all changes in this revision

Viewing changes to src/emu/cpu/dsp32/dsp32ops.c

  • Committer: Bazaar Package Importer
  • Author(s): Jordi Mallach, Emmanuel Kasper, Félix Arreola Rodríguez, Jordi Mallach
  • Date: 2011-05-11 21:06:50 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20110511210650-jizvh8a6x117y9hr
Tags: 0.142-1
[ Emmanuel Kasper ]
* New upstream release
* Set NOWERROR=1 to allow compiling with gcc-4.6
* Remove fix_powerpc_build.patch, as upstream has taken it in this release
* Add gnome-video-arcade front end as a suggested package

[ Félix Arreola Rodríguez ]
* Add kfreebsd-build.patch to quilt series, to fix build on kfreebsd

[ Jordi Mallach ]
* Remove unneeded and bogus addition of --with-quilt to the dh invocation.
* Add Cesare Falco (long time Ubuntu maintainer) to Uploaders, and wrap
  them into multiple lines.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/emu/cpu/dsp32/dsp32ops.c
2
2
 
3
3
    dsp32ops.c
4
4
    Core implementation for the portable DSP32 emulator.
5
 
    Written by Aaron Giles
6
 
 
7
 
***************************************************************************/
8
 
 
9
 
 
10
 
 
11
 
/***************************************************************************
12
 
    COMPILE-TIME OPTIONS
13
 
***************************************************************************/
14
 
 
15
 
/* these defined latencies are a pain to implement, but are necessary */
 
5
 
 
6
****************************************************************************
 
7
 
 
8
    Copyright Aaron Giles
 
9
    All rights reserved.
 
10
 
 
11
    Redistribution and use in source and binary forms, with or without
 
12
    modification, are permitted provided that the following conditions are
 
13
    met:
 
14
 
 
15
        * Redistributions of source code must retain the above copyright
 
16
          notice, this list of conditions and the following disclaimer.
 
17
        * Redistributions in binary form must reproduce the above copyright
 
18
          notice, this list of conditions and the following disclaimer in
 
19
          the documentation and/or other materials provided with the
 
20
          distribution.
 
21
        * Neither the name 'MAME' nor the names of its contributors may be
 
22
          used to endorse or promote products derived from this software
 
23
          without specific prior written permission.
 
24
 
 
25
    THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
 
26
    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 
27
    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 
28
    DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
 
29
    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 
30
    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 
31
    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 
32
    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 
33
    STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 
34
    IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 
35
    POSSIBILITY OF SUCH DAMAGE.
 
36
 
 
37
****************************************************************************/
 
38
 
 
39
 
 
40
 
 
41
//**************************************************************************
 
42
//  COMPILE-TIME OPTIONS
 
43
//**************************************************************************
 
44
 
 
45
// these defined latencies are a pain to implement, but are necessary
16
46
#define EMULATE_MEMORY_LATENCY          (1)
17
47
#define EMULATE_MULTIPLIER_LATENCY      (1)
18
48
#define EMULATE_AFLAGS_LATENCY          (1)
19
49
 
20
 
/* these optimizations should have some effect, but they don't really, so */
21
 
/* leave them off */
 
50
// these optimizations should have some effect, but they don't really, so
 
51
// leave them off
22
52
#define IGNORE_DAU_UV_FLAGS                     (0)
23
53
#define ASSUME_WRITEABLE                        (0)
24
54
#define ASSUME_UNCONDITIONAL_CAU        (0)
25
55
 
26
56
 
27
57
 
28
 
/***************************************************************************
29
 
    MACROS
30
 
***************************************************************************/
31
 
 
32
 
#define SET_V_16(cs,a,b,r)              (cs)->vflags = (((a) ^ (b) ^ (r) ^ ((r) >> 1)) << 8)
33
 
#define SET_NZC_16(cs,r)                (cs)->nzcflags = ((r) << 8)
34
 
#define SET_NZCV_16(cs,a,b,r)   SET_NZC_16(cs,r); SET_V_16(cs,a,b,r)
35
 
#define SET_NZ00_16(cs,r)               (cs)->nzcflags = (((r) << 8) & 0xffffff); (cs)->vflags = 0
36
 
 
37
 
#define SET_V_24(cs,a,b,r)              (cs)->vflags = ((a) ^ (b) ^ (r) ^ ((r) >> 1))
38
 
#define SET_NZC_24(cs,r)                (cs)->nzcflags = (r)
39
 
#define SET_NZCV_24(cs,a,b,r)   SET_NZC_24(cs,r); SET_V_24(cs,a,b,r)
40
 
#define SET_NZ00_24(cs,r)               (cs)->nzcflags = ((r) & 0xffffff); (cs)->vflags = 0
 
58
//**************************************************************************
 
59
//  MACROS
 
60
//**************************************************************************
 
61
 
 
62
#define SET_V_16(a,b,r)                 m_vflags = (((a) ^ (b) ^ (r) ^ ((r) >> 1)) << 8)
 
63
#define SET_NZC_16(r)                   m_nzcflags = ((r) << 8)
 
64
#define SET_NZCV_16(a,b,r)              SET_NZC_16(r); SET_V_16(a,b,r)
 
65
#define SET_NZ00_16(r)                  m_nzcflags = (((r) << 8) & 0xffffff); m_vflags = 0
 
66
 
 
67
#define SET_V_24(a,b,r)                 m_vflags = ((a) ^ (b) ^ (r) ^ ((r) >> 1))
 
68
#define SET_NZC_24(r)                   m_nzcflags = (r)
 
69
#define SET_NZCV_24(a,b,r)              SET_NZC_24(r); SET_V_24(a,b,r)
 
70
#define SET_NZ00_24(r)                  m_nzcflags = ((r) & 0xffffff); m_vflags = 0
41
71
 
42
72
#define TRUNCATE24(a)                   ((a) & 0xffffff)
43
73
#define EXTEND16_TO_24(a)               TRUNCATE24((INT32)(INT16)(a))
44
 
#define REG16(cs,a)                             ((UINT16)(cs)->r[a])
45
 
#define REG24(cs,a)                             ((cs)->r[a])
 
74
#define REG16(a)                                ((UINT16)m_r[a])
 
75
#define REG24(a)                                (m_r[a])
46
76
 
47
77
#define WRITEABLE_REGS                  (0x6f3efffe)
48
78
#if ASSUME_WRITEABLE
52
82
#endif
53
83
 
54
84
#if ASSUME_UNCONDITIONAL_CAU
55
 
#define CONDITION_IS_TRUE(cs)   (1)
 
85
#define CONDITION_IS_TRUE()             (1)
56
86
#else
57
 
#define CONDITION_IS_TRUE(cs)   (!(op & 0x400) || (condition(cs, (op >> 12) & 15)))
 
87
#define CONDITION_IS_TRUE()             (!(op & 0x400) || (condition((op >> 12) & 15)))
58
88
#endif
59
89
 
60
90
#if EMULATE_MEMORY_LATENCY
61
 
#define WWORD_DEFERRED(cs,a,v)  do { int bufidx = (cs)->mbuf_index & 3; (cs)->mbufaddr[bufidx] = -(a); (cs)->mbufdata[bufidx] = (v); } while (0)
62
 
#define WLONG_DEFERRED(cs,a,v)  do { int bufidx = (cs)->mbuf_index & 3; (cs)->mbufaddr[bufidx] = (a); (cs)->mbufdata[bufidx] = (v); } while (0)
63
 
#define PROCESS_DEFERRED_MEMORY(cs)                                                                     \
64
 
        if ((cs)->mbufaddr[++(cs)->mbuf_index & 3] != 1)                                        \
 
91
#define WWORD_DEFERRED(a,v)             do { int bufidx = m_mbuf_index & 3; m_mbufaddr[bufidx] = -(a); m_mbufdata[bufidx] = (v); } while (0)
 
92
#define WLONG_DEFERRED(a,v)             do { int bufidx = m_mbuf_index & 3; m_mbufaddr[bufidx] = (a); m_mbufdata[bufidx] = (v); } while (0)
 
93
#define PROCESS_DEFERRED_MEMORY()                                                                       \
 
94
        if (m_mbufaddr[++m_mbuf_index & 3] != 1)                                        \
65
95
        {                                                                                                                                       \
66
 
                int bufidx = (cs)->mbuf_index & 3;                                                              \
67
 
                if ((cs)->mbufaddr[bufidx] >= 0)                                                                \
68
 
                        WLONG(cs, (cs)->mbufaddr[bufidx], (cs)->mbufdata[bufidx]);      \
 
96
                int bufidx = m_mbuf_index & 3;                                                          \
 
97
                if (m_mbufaddr[bufidx] >= 0)                                                            \
 
98
                        WLONG(m_mbufaddr[bufidx], m_mbufdata[bufidx]);  \
69
99
                else                                                                                                                    \
70
 
                        WWORD(cs, -(cs)->mbufaddr[bufidx], (cs)->mbufdata[bufidx]);     \
71
 
                (cs)->mbufaddr[bufidx] = 1;                                                                             \
 
100
                        WWORD(-m_mbufaddr[bufidx], m_mbufdata[bufidx]); \
 
101
                m_mbufaddr[bufidx] = 1;                                                                         \
72
102
        }
73
103
#else
74
 
#define WWORD_DEFERRED(cs,a,v)  WWORD(cs,a,v)
75
 
#define WLONG_DEFERRED(cs,a,v)  WLONG(cs,a,v)
76
 
#define PROCESS_DEFERRED_MEMORY(cs)
 
104
#define WWORD_DEFERRED(a,v)     WWORD(a,v)
 
105
#define WLONG_DEFERRED(a,v)     WLONG(a,v)
 
106
#define PROCESS_DEFERRED_MEMORY()
77
107
#endif
78
108
 
79
109
#if EMULATE_MULTIPLIER_LATENCY
80
 
#define DEFERRED_MULTIPLIER(cs,x)       dau_get_amult(cs, x)
 
110
#define DEFERRED_MULTIPLIER(x)  dau_get_amult(x)
81
111
#else
82
 
#define DEFERRED_MULTIPLIER(cs,x)       (cs)->a[x]
 
112
#define DEFERRED_MULTIPLIER(x)  m_a[x]
83
113
#endif
84
114
 
85
115
#if EMULATE_AFLAGS_LATENCY
86
 
#define DEFERRED_NZFLAGS(cs)    dau_get_anzflags(cs)
87
 
#define DEFERRED_VUFLAGS(cs)    dau_get_avuflags(cs)
 
116
#define DEFERRED_NZFLAGS()      dau_get_anzflags()
 
117
#define DEFERRED_VUFLAGS()      dau_get_avuflags()
88
118
#else
89
 
#define DEFERRED_NZFLAGS(cs)    (cs)->NZflags
90
 
#define DEFERRED_VUFLAGS(cs)    (cs)->VUflags
 
119
#define DEFERRED_NZFLAGS()      m_NZflags
 
120
#define DEFERRED_VUFLAGS()      m_VUflags
91
121
#endif
92
122
 
93
123
 
94
124
 
95
 
/***************************************************************************
96
 
    FORWARD DECLARATIONS
97
 
***************************************************************************/
98
 
 
99
 
extern void (*const dsp32ops[])(dsp32_state *cpustate, UINT32 op);
100
 
 
101
 
 
102
 
 
103
 
/***************************************************************************
104
 
    TYPEDEFS
105
 
***************************************************************************/
106
 
 
107
 
typedef union int_double
 
125
//**************************************************************************
 
126
//  TYPEDEFS
 
127
//**************************************************************************
 
128
 
 
129
union int_double
108
130
{
109
131
        double d;
110
132
        UINT32 i[2];
111
 
} int_double;
112
 
 
113
 
 
114
 
 
115
 
/***************************************************************************
116
 
    IMPLEMENTATION
117
 
***************************************************************************/
118
 
 
119
 
static void illegal(dsp32_state *cpustate, UINT32 op)
120
 
{
121
 
}
122
 
 
123
 
 
124
 
static void unimplemented(dsp32_state *cpustate, UINT32 op)
125
 
{
126
 
    fatalerror("Unimplemented op @ %06X: %08X (dis=%02X, tbl=%03X)", cpustate->PC - 4, op, op >> 25, op >> 21);
127
 
}
128
 
 
129
 
 
130
 
INLINE void execute_one(dsp32_state *cpustate)
 
133
};
 
134
 
 
135
 
 
136
 
 
137
//**************************************************************************
 
138
//  IMPLEMENTATION
 
139
//**************************************************************************
 
140
 
 
141
void dsp32c_device::illegal(UINT32 op)
 
142
{
 
143
}
 
144
 
 
145
 
 
146
void dsp32c_device::unimplemented(UINT32 op)
 
147
{
 
148
    fatalerror("Unimplemented op @ %06X: %08X (dis=%02X, tbl=%03X)", PC - 4, op, op >> 25, op >> 21);
 
149
}
 
150
 
 
151
 
 
152
inline void dsp32c_device::execute_one()
131
153
{
132
154
        UINT32 op;
133
155
 
134
 
        PROCESS_DEFERRED_MEMORY(cpustate);
135
 
        debugger_instruction_hook(cpustate->device, cpustate->PC);
136
 
        op = ROPCODE(cpustate, cpustate->PC);
137
 
        cpustate->icount -= 4;  /* 4 clocks per cycle */
138
 
        cpustate->PC += 4;
 
156
        PROCESS_DEFERRED_MEMORY();
 
157
        debugger_instruction_hook(this, PC);
 
158
        op = ROPCODE(PC);
 
159
        m_icount -= 4;  // 4 clocks per cycle
 
160
        PC += 4;
139
161
        if (op)
140
 
                (*dsp32ops[op >> 21])(cpustate, op);
 
162
                (this->*s_dsp32ops[op >> 21])(op);
141
163
}
142
164
 
143
165
 
144
166
 
145
 
/***************************************************************************
146
 
    CAU HELPERS
147
 
***************************************************************************/
 
167
//**************************************************************************
 
168
//  CAU HELPERS
 
169
//**************************************************************************
148
170
 
149
 
static UINT32 cau_read_pi_special(dsp32_state *cpustate, UINT8 i)
 
171
UINT32 dsp32c_device::cau_read_pi_special(UINT8 i)
150
172
{
151
173
        switch (i)
152
174
        {
153
 
                case 4:         return cpustate->ibuf;
154
 
                case 5:         return cpustate->obuf;
155
 
                case 6:         update_pcr(cpustate, cpustate->pcr & ~PCR_PDFs); return cpustate->pdr;
156
 
                case 14:        return cpustate->piop;
157
 
                case 20:        return cpustate->pdr2;
158
 
                case 22:        update_pcr(cpustate, cpustate->pcr & ~PCR_PIFs); return cpustate->pir;
159
 
                case 30:        return cpustate->pcw;
 
175
                case 4:         return m_ibuf;
 
176
                case 5:         return m_obuf;
 
177
                case 6:         update_pcr(m_pcr & ~PCR_PDFs); return m_pdr;
 
178
                case 14:        return m_piop;
 
179
                case 20:        return m_pdr2;
 
180
                case 22:        update_pcr(m_pcr & ~PCR_PIFs); return m_pir;
 
181
                case 30:        return m_pcw;
160
182
                default:        fprintf(stderr, "Unimplemented CAU PI read = %X\n", i);
161
183
        }
162
184
        return 0;
163
185
}
164
186
 
165
187
 
166
 
static void cau_write_pi_special(dsp32_state *cpustate, UINT8 i, UINT32 val)
 
188
void dsp32c_device::cau_write_pi_special(UINT8 i, UINT32 val)
167
189
{
168
190
        switch (i)
169
191
        {
170
 
                case 4:         cpustate->ibuf = val;   break;
171
 
                case 5:         cpustate->obuf = val;   break;
172
 
                case 6:         cpustate->pdr = val; update_pcr(cpustate, cpustate->pcr | PCR_PDFs); break;
173
 
                case 14:        cpustate->piop = val;   break;
174
 
                case 20:        cpustate->pdr2 = val;   break;
175
 
                case 22:        cpustate->pir = val; update_pcr(cpustate, cpustate->pcr | PCR_PIFs); break;
176
 
                case 30:        cpustate->pcw = val;    break;
 
192
                case 4:         m_ibuf = val;   break;
 
193
                case 5:         m_obuf = val;   break;
 
194
                case 6:         m_pdr = val; update_pcr(m_pcr | PCR_PDFs); break;
 
195
                case 14:        m_piop = val;   break;
 
196
                case 20:        m_pdr2 = val;   break;
 
197
                case 22:        m_pir = val; update_pcr(m_pcr | PCR_PIFs); break;
 
198
                case 30:        m_pcw = val;    break;
177
199
                default:        fprintf(stderr, "Unimplemented CAU PI write = %X\n", i);
178
200
        }
179
201
}
180
202
 
181
203
 
182
 
INLINE UINT8 cau_read_pi_1byte(dsp32_state *cpustate, int pi)
183
 
{
184
 
        int p = (pi >> 5) & 0x1f;
185
 
        int i = (pi >> 0) & 0x1f;
186
 
        if (p)
187
 
        {
188
 
                UINT32 result = RBYTE(cpustate, cpustate->r[p]);
189
 
                cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i]);
190
 
                return result;
191
 
        }
192
 
        else
193
 
                return cau_read_pi_special(cpustate, i);
194
 
}
195
 
 
196
 
 
197
 
INLINE UINT16 cau_read_pi_2byte(dsp32_state *cpustate, int pi)
198
 
{
199
 
        int p = (pi >> 5) & 0x1f;
200
 
        int i = (pi >> 0) & 0x1f;
201
 
        if (p)
202
 
        {
203
 
                UINT32 result = RWORD(cpustate, cpustate->r[p]);
204
 
                if (i < 22 || i > 23)
205
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i]);
206
 
                else
207
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i] * 2);
208
 
                return result;
209
 
        }
210
 
        else
211
 
                return cau_read_pi_special(cpustate, i);
212
 
}
213
 
 
214
 
 
215
 
INLINE UINT32 cau_read_pi_4byte(dsp32_state *cpustate, int pi)
216
 
{
217
 
        int p = (pi >> 5) & 0x1f;
218
 
        int i = (pi >> 0) & 0x1f;
219
 
        if (p)
220
 
        {
221
 
                UINT32 result = RLONG(cpustate, cpustate->r[p]);
222
 
                if (i < 22 || i > 23)
223
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i]);
224
 
                else
225
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i] * 4);
226
 
                return result;
227
 
        }
228
 
        else
229
 
                return cau_read_pi_special(cpustate, i);
230
 
}
231
 
 
232
 
 
233
 
INLINE void cau_write_pi_1byte(dsp32_state *cpustate, int pi, UINT8 val)
234
 
{
235
 
        int p = (pi >> 5) & 0x1f;
236
 
        int i = (pi >> 0) & 0x1f;
237
 
        if (p)
238
 
        {
239
 
                WBYTE(cpustate, cpustate->r[p], val);
240
 
                cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i]);
241
 
        }
242
 
        else
243
 
                cau_write_pi_special(cpustate, i, val);
244
 
}
245
 
 
246
 
 
247
 
INLINE void cau_write_pi_2byte(dsp32_state *cpustate, int pi, UINT16 val)
248
 
{
249
 
        int p = (pi >> 5) & 0x1f;
250
 
        int i = (pi >> 0) & 0x1f;
251
 
        if (p)
252
 
        {
253
 
                WWORD(cpustate, cpustate->r[p], val);
254
 
                if (i < 22 || i > 23)
255
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i]);
256
 
                else
257
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i] * 2);
258
 
        }
259
 
        else
260
 
                cau_write_pi_special(cpustate, i, val);
261
 
}
262
 
 
263
 
 
264
 
INLINE void cau_write_pi_4byte(dsp32_state *cpustate, int pi, UINT32 val)
265
 
{
266
 
        int p = (pi >> 5) & 0x1f;
267
 
        int i = (pi >> 0) & 0x1f;
268
 
        if (p)
269
 
        {
270
 
                WLONG(cpustate, cpustate->r[p], (INT32)(val << 8) >> 8);
271
 
                if (i < 22 || i > 23)
272
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i]);
273
 
                else
274
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i] * 4);
275
 
        }
276
 
        else
277
 
                cau_write_pi_special(cpustate, i, val);
278
 
}
279
 
 
280
 
 
281
 
 
282
 
/***************************************************************************
283
 
    DAU HELPERS
284
 
***************************************************************************/
285
 
 
286
 
INLINE double dau_get_amult(dsp32_state *cpustate, int aidx)
287
 
{
288
 
        int bufidx = (cpustate->abuf_index - 1) & 3;
289
 
        double val = cpustate->a[aidx];
290
 
        while (cpustate->icount >= cpustate->abufcycle[bufidx] - 2 * 4)
291
 
        {
292
 
                if (cpustate->abufreg[bufidx] == aidx)
293
 
                        val = cpustate->abuf[bufidx];
 
204
inline UINT8 dsp32c_device::cau_read_pi_1byte(int pi)
 
205
{
 
206
        int p = (pi >> 5) & 0x1f;
 
207
        int i = (pi >> 0) & 0x1f;
 
208
        if (p)
 
209
        {
 
210
                UINT32 result = RBYTE(m_r[p]);
 
211
                m_r[p] = TRUNCATE24(m_r[p] + m_r[i]);
 
212
                return result;
 
213
        }
 
214
        else
 
215
                return cau_read_pi_special(i);
 
216
}
 
217
 
 
218
 
 
219
inline UINT16 dsp32c_device::cau_read_pi_2byte(int pi)
 
220
{
 
221
        int p = (pi >> 5) & 0x1f;
 
222
        int i = (pi >> 0) & 0x1f;
 
223
        if (p)
 
224
        {
 
225
                UINT32 result = RWORD(m_r[p]);
 
226
                if (i < 22 || i > 23)
 
227
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i]);
 
228
                else
 
229
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i] * 2);
 
230
                return result;
 
231
        }
 
232
        else
 
233
                return cau_read_pi_special(i);
 
234
}
 
235
 
 
236
 
 
237
inline UINT32 dsp32c_device::cau_read_pi_4byte(int pi)
 
238
{
 
239
        int p = (pi >> 5) & 0x1f;
 
240
        int i = (pi >> 0) & 0x1f;
 
241
        if (p)
 
242
        {
 
243
                UINT32 result = RLONG(m_r[p]);
 
244
                if (i < 22 || i > 23)
 
245
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i]);
 
246
                else
 
247
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i] * 4);
 
248
                return result;
 
249
        }
 
250
        else
 
251
                return cau_read_pi_special(i);
 
252
}
 
253
 
 
254
 
 
255
inline void dsp32c_device::cau_write_pi_1byte(int pi, UINT8 val)
 
256
{
 
257
        int p = (pi >> 5) & 0x1f;
 
258
        int i = (pi >> 0) & 0x1f;
 
259
        if (p)
 
260
        {
 
261
                WBYTE(m_r[p], val);
 
262
                m_r[p] = TRUNCATE24(m_r[p] + m_r[i]);
 
263
        }
 
264
        else
 
265
                cau_write_pi_special(i, val);
 
266
}
 
267
 
 
268
 
 
269
inline void dsp32c_device::cau_write_pi_2byte(int pi, UINT16 val)
 
270
{
 
271
        int p = (pi >> 5) & 0x1f;
 
272
        int i = (pi >> 0) & 0x1f;
 
273
        if (p)
 
274
        {
 
275
                WWORD(m_r[p], val);
 
276
                if (i < 22 || i > 23)
 
277
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i]);
 
278
                else
 
279
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i] * 2);
 
280
        }
 
281
        else
 
282
                cau_write_pi_special(i, val);
 
283
}
 
284
 
 
285
 
 
286
inline void dsp32c_device::cau_write_pi_4byte(int pi, UINT32 val)
 
287
{
 
288
        int p = (pi >> 5) & 0x1f;
 
289
        int i = (pi >> 0) & 0x1f;
 
290
        if (p)
 
291
        {
 
292
                WLONG(m_r[p], (INT32)(val << 8) >> 8);
 
293
                if (i < 22 || i > 23)
 
294
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i]);
 
295
                else
 
296
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i] * 4);
 
297
        }
 
298
        else
 
299
                cau_write_pi_special(i, val);
 
300
}
 
301
 
 
302
 
 
303
 
 
304
//**************************************************************************
 
305
//  DAU HELPERS
 
306
//**************************************************************************
 
307
 
 
308
inline double dsp32c_device::dau_get_amult(int aidx)
 
309
{
 
310
        int bufidx = (m_abuf_index - 1) & 3;
 
311
        double val = m_a[aidx];
 
312
        while (m_icount >= m_abufcycle[bufidx] - 2 * 4)
 
313
        {
 
314
                if (m_abufreg[bufidx] == aidx)
 
315
                        val = m_abuf[bufidx];
294
316
                bufidx = (bufidx - 1) & 3;
295
317
        }
296
318
        return val;
297
319
}
298
320
 
299
321
 
300
 
INLINE double dau_get_anzflags(dsp32_state *cpustate)
 
322
inline double dsp32c_device::dau_get_anzflags()
301
323
{
302
 
        int bufidx = (cpustate->abuf_index - 1) & 3;
303
 
        double nzflags = cpustate->NZflags;
304
 
        while (cpustate->icount >= cpustate->abufcycle[bufidx] - 3 * 4)
 
324
        int bufidx = (m_abuf_index - 1) & 3;
 
325
        double nzflags = m_NZflags;
 
326
        while (m_icount >= m_abufcycle[bufidx] - 3 * 4)
305
327
        {
306
 
                nzflags = cpustate->abufNZflags[bufidx];
 
328
                nzflags = m_abufNZflags[bufidx];
307
329
                bufidx = (bufidx - 1) & 3;
308
330
        }
309
331
        return nzflags;
310
332
}
311
333
 
312
334
 
313
 
INLINE UINT8 dau_get_avuflags(dsp32_state *cpustate)
 
335
inline UINT8 dsp32c_device::dau_get_avuflags()
314
336
{
315
337
#if (!IGNORE_DAU_UV_FLAGS)
316
 
        int bufidx = (cpustate->abuf_index - 1) & 3;
317
 
        UINT8 vuflags = cpustate->VUflags;
318
 
        while (cpustate->icount >= cpustate->abufcycle[bufidx] - 3 * 4)
 
338
        int bufidx = (m_abuf_index - 1) & 3;
 
339
        UINT8 vuflags = m_VUflags;
 
340
        while (m_icount >= m_abufcycle[bufidx] - 3 * 4)
319
341
        {
320
 
                vuflags = cpustate->abufVUflags[bufidx];
 
342
                vuflags = m_abufVUflags[bufidx];
321
343
                bufidx = (bufidx - 1) & 3;
322
344
        }
323
345
        return vuflags;
327
349
}
328
350
 
329
351
 
330
 
INLINE void remember_last_dau(dsp32_state *cpustate, int aidx)
 
352
inline void dsp32c_device::remember_last_dau(int aidx)
331
353
{
332
354
#if (EMULATE_MULTIPLIER_LATENCY || EMULATE_AFLAGS_LATENCY)
333
 
        int bufidx = cpustate->abuf_index++ & 3;
334
 
        cpustate->abuf[bufidx] = cpustate->a[aidx];
335
 
        cpustate->abufreg[bufidx] = aidx;
336
 
        cpustate->abufNZflags[bufidx] = cpustate->NZflags;
 
355
        int bufidx = m_abuf_index++ & 3;
 
356
        m_abuf[bufidx] = m_a[aidx];
 
357
        m_abufreg[bufidx] = aidx;
 
358
        m_abufNZflags[bufidx] = m_NZflags;
337
359
#if (!IGNORE_DAU_UV_FLAGS)
338
 
        cpustate->abufVUflags[bufidx] = cpustate->VUflags;
339
 
#endif
340
 
        cpustate->abufcycle[bufidx] = cpustate->icount;
341
 
#endif
342
 
}
343
 
 
344
 
 
345
 
INLINE void dau_set_val_noflags(dsp32_state *cpustate, int aidx, double res)
346
 
{
347
 
        remember_last_dau(cpustate, aidx);
348
 
        cpustate->a[aidx] = res;
349
 
}
350
 
 
351
 
 
352
 
INLINE void dau_set_val_flags(dsp32_state *cpustate, int aidx, double res)
353
 
{
354
 
        remember_last_dau(cpustate, aidx);
 
360
        m_abufVUflags[bufidx] = m_VUflags;
 
361
#endif
 
362
        m_abufcycle[bufidx] = m_icount;
 
363
#endif
 
364
}
 
365
 
 
366
 
 
367
inline void dsp32c_device::dau_set_val_noflags(int aidx, double res)
 
368
{
 
369
        remember_last_dau(aidx);
 
370
        m_a[aidx] = res;
 
371
}
 
372
 
 
373
 
 
374
inline void dsp32c_device::dau_set_val_flags(int aidx, double res)
 
375
{
 
376
        remember_last_dau(aidx);
355
377
#if (!IGNORE_DAU_UV_FLAGS)
356
378
{
357
379
        double absres = (res < 0) ? -res : res;
358
 
        cpustate->VUflags = 0;
 
380
        m_VUflags = 0;
359
381
        if (absres < 5.87747e-39)
360
382
        {
361
383
                if (absres != 0)
362
 
                        cpustate->VUflags = UFLAGBIT;
 
384
                        m_VUflags = UFLAGBIT;
363
385
                res = 0.0;
364
386
        }
365
387
        else if (absres > 3.40282e38)
366
388
        {
367
 
                cpustate->VUflags = VFLAGBIT;
 
389
                m_VUflags = VFLAGBIT;
368
390
//      debugger_break(Machine);
369
391
//      fprintf(stderr, "Result = %g\n", absres);
370
392
                res = (res < 0) ? -3.40282e38 : 3.40282e38;
371
393
        }
372
394
}
373
395
#endif
374
 
        cpustate->NZflags = res;
375
 
        cpustate->a[aidx] = res;
 
396
        m_NZflags = res;
 
397
        m_a[aidx] = res;
376
398
}
377
399
 
378
400
 
379
 
INLINE double dsp_to_double(UINT32 val)
 
401
inline double dsp32c_device::dsp_to_double(UINT32 val)
380
402
{
381
403
        int_double id;
382
404
 
399
421
}
400
422
 
401
423
 
402
 
INLINE UINT32 double_to_dsp(double val)
 
424
inline UINT32 dsp32c_device::double_to_dsp(double val)
403
425
{
404
426
        int mantissa, exponent;
405
427
        int_double id;
425
447
}
426
448
 
427
449
 
428
 
static double dau_read_pi_special(dsp32_state *cpustate, int i)
 
450
double dsp32c_device::dau_read_pi_special(int i)
429
451
{
430
452
    fatalerror("Unimplemented dau_read_pi_special(%d)", i);
431
453
        return 0;
432
454
}
433
455
 
434
456
 
435
 
static void dau_write_pi_special(dsp32_state *cpustate, int i, double val)
 
457
void dsp32c_device::dau_write_pi_special(int i, double val)
436
458
{
437
459
    fatalerror("Unimplemented dau_write_pi_special(%d)", i);
438
460
}
439
461
 
440
462
 
441
 
static int lastp;
442
 
 
443
 
INLINE double dau_read_pi_double_1st(dsp32_state *cpustate, int pi, int multiplier)
 
463
inline double dsp32c_device::dau_read_pi_double_1st(int pi, int multiplier)
444
464
{
445
465
        int p = (pi >> 3) & 15;
446
466
        int i = (pi >> 0) & 7;
447
467
 
448
 
        lastp = p;
 
468
        m_lastp = p;
449
469
        if (p)
450
470
        {
451
 
                UINT32 result = RLONG(cpustate, cpustate->r[p]);
 
471
                UINT32 result = RLONG(m_r[p]);
452
472
                if (i < 6)
453
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i+16]);
 
473
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i+16]);
454
474
                else
455
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i+16] * 4);
 
475
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i+16] * 4);
456
476
                return dsp_to_double(result);
457
477
        }
458
478
        else if (i < 4)
459
 
                return multiplier ? DEFERRED_MULTIPLIER(cpustate, i) : cpustate->a[i];
 
479
                return multiplier ? DEFERRED_MULTIPLIER(i) : m_a[i];
460
480
        else
461
 
                return dau_read_pi_special(cpustate, i);
 
481
                return dau_read_pi_special(i);
462
482
}
463
483
 
464
484
 
465
 
INLINE double dau_read_pi_double_2nd(dsp32_state *cpustate, int pi, int multiplier, double xval)
 
485
inline double dsp32c_device::dau_read_pi_double_2nd(int pi, int multiplier, double xval)
466
486
{
467
487
        int p = (pi >> 3) & 15;
468
488
        int i = (pi >> 0) & 7;
469
489
 
470
 
        if (p == 15) p = lastp;         /* P=15 means Z inherits from Y, Y inherits from X */
471
 
        lastp = p;
 
490
        if (p == 15) p = m_lastp;               // P=15 means Z inherits from Y, Y inherits from X
 
491
        m_lastp = p;
472
492
        if (p)
473
493
        {
474
494
                UINT32 result;
475
 
                result = RLONG(cpustate, cpustate->r[p]);
 
495
                result = RLONG(m_r[p]);
476
496
                if (i < 6)
477
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i+16]);
 
497
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i+16]);
478
498
                else
479
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i+16] * 4);
 
499
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i+16] * 4);
480
500
                return dsp_to_double(result);
481
501
        }
482
502
        else if (i < 4)
483
 
                return multiplier ? DEFERRED_MULTIPLIER(cpustate, i) : cpustate->a[i];
484
 
        else
485
 
                return dau_read_pi_special(cpustate, i);
486
 
}
487
 
 
488
 
 
489
 
INLINE UINT32 dau_read_pi_4bytes(dsp32_state *cpustate, int pi)
490
 
{
491
 
        int p = (pi >> 3) & 15;
492
 
        int i = (pi >> 0) & 7;
493
 
 
494
 
        lastp = p;
495
 
        if (p)
496
 
        {
497
 
                UINT32 result = RLONG(cpustate, cpustate->r[p]);
498
 
                if (i < 6)
499
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i+16]);
500
 
                else
501
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i+16] * 4);
502
 
                return result;
503
 
        }
504
 
        else if (i < 4)
505
 
                return double_to_dsp(cpustate->a[i]);
506
 
        else
507
 
                return dau_read_pi_special(cpustate, i);
508
 
}
509
 
 
510
 
 
511
 
INLINE UINT16 dau_read_pi_2bytes(dsp32_state *cpustate, int pi)
512
 
{
513
 
        int p = (pi >> 3) & 15;
514
 
        int i = (pi >> 0) & 7;
515
 
 
516
 
        lastp = p;
517
 
        if (p)
518
 
        {
519
 
                UINT32 result = RWORD(cpustate, cpustate->r[p]);
520
 
                if (i < 6)
521
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i+16]);
522
 
                else
523
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i+16] * 2);
524
 
                return result;
525
 
        }
526
 
        else if (i < 4)
527
 
                return double_to_dsp(cpustate->a[i]);
528
 
        else
529
 
                return dau_read_pi_special(cpustate, i);
530
 
}
531
 
 
532
 
 
533
 
INLINE void dau_write_pi_double(dsp32_state *cpustate, int pi, double val)
534
 
{
535
 
        int p = (pi >> 3) & 15;
536
 
        int i = (pi >> 0) & 7;
537
 
 
538
 
        if (p == 15) p = lastp;         /* P=15 means Z inherits from Y, Y inherits from X */
539
 
        if (p)
540
 
        {
541
 
                WLONG_DEFERRED(cpustate, cpustate->r[p], double_to_dsp(val));
542
 
                if (i < 6)
543
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i+16]);
544
 
                else
545
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i+16] * 4);
546
 
        }
547
 
        else if (i < 4)
548
 
                dau_set_val_noflags(cpustate, i, val);
549
 
        else
550
 
                dau_write_pi_special(cpustate, i, val);
551
 
}
552
 
 
553
 
 
554
 
INLINE void dau_write_pi_4bytes(dsp32_state *cpustate, int pi, UINT32 val)
555
 
{
556
 
        int p = (pi >> 3) & 15;
557
 
        int i = (pi >> 0) & 7;
558
 
 
559
 
        if (p == 15) p = lastp;         /* P=15 means Z inherits from Y, Y inherits from X */
560
 
        if (p)
561
 
        {
562
 
                lastp = p;
563
 
                WLONG_DEFERRED(cpustate, cpustate->r[p], val);
564
 
                if (i < 6)
565
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i+16]);
566
 
                else
567
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i+16] * 4);
568
 
        }
569
 
        else if (i < 4)
570
 
                dau_set_val_noflags(cpustate, i, dsp_to_double(val));
571
 
        else
572
 
                dau_write_pi_special(cpustate, i, val);
573
 
}
574
 
 
575
 
 
576
 
INLINE void dau_write_pi_2bytes(dsp32_state *cpustate, int pi, UINT16 val)
577
 
{
578
 
        int p = (pi >> 3) & 15;
579
 
        int i = (pi >> 0) & 7;
580
 
 
581
 
        if (p == 15) p = lastp;         /* P=15 means Z inherits from Y, Y inherits from X */
582
 
        if (p)
583
 
        {
584
 
                lastp = p;
585
 
                WWORD_DEFERRED(cpustate, cpustate->r[p], val);
586
 
                if (i < 6)
587
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i+16]);
588
 
                else
589
 
                        cpustate->r[p] = TRUNCATE24(cpustate->r[p] + cpustate->r[i+16] * 2);
590
 
        }
591
 
        else if (i < 4)
592
 
                dau_set_val_noflags(cpustate, i, dsp_to_double(val << 16));
593
 
        else
594
 
                dau_write_pi_special(cpustate, i, val);
595
 
}
596
 
 
597
 
 
598
 
 
599
 
/***************************************************************************
600
 
    COMMON CONDITION ROUTINE
601
 
***************************************************************************/
 
503
                return multiplier ? DEFERRED_MULTIPLIER(i) : m_a[i];
 
504
        else
 
505
                return dau_read_pi_special(i);
 
506
}
 
507
 
 
508
 
 
509
inline UINT32 dsp32c_device::dau_read_pi_4bytes(int pi)
 
510
{
 
511
        int p = (pi >> 3) & 15;
 
512
        int i = (pi >> 0) & 7;
 
513
 
 
514
        m_lastp = p;
 
515
        if (p)
 
516
        {
 
517
                UINT32 result = RLONG(m_r[p]);
 
518
                if (i < 6)
 
519
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i+16]);
 
520
                else
 
521
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i+16] * 4);
 
522
                return result;
 
523
        }
 
524
        else if (i < 4)
 
525
                return double_to_dsp(m_a[i]);
 
526
        else
 
527
                return dau_read_pi_special(i);
 
528
}
 
529
 
 
530
 
 
531
inline UINT16 dsp32c_device::dau_read_pi_2bytes(int pi)
 
532
{
 
533
        int p = (pi >> 3) & 15;
 
534
        int i = (pi >> 0) & 7;
 
535
 
 
536
        m_lastp = p;
 
537
        if (p)
 
538
        {
 
539
                UINT32 result = RWORD(m_r[p]);
 
540
                if (i < 6)
 
541
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i+16]);
 
542
                else
 
543
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i+16] * 2);
 
544
                return result;
 
545
        }
 
546
        else if (i < 4)
 
547
                return double_to_dsp(m_a[i]);
 
548
        else
 
549
                return dau_read_pi_special(i);
 
550
}
 
551
 
 
552
 
 
553
inline void dsp32c_device::dau_write_pi_double(int pi, double val)
 
554
{
 
555
        int p = (pi >> 3) & 15;
 
556
        int i = (pi >> 0) & 7;
 
557
 
 
558
        if (p == 15) p = m_lastp;               // P=15 means Z inherits from Y, Y inherits from X
 
559
        if (p)
 
560
        {
 
561
                WLONG_DEFERRED(m_r[p], double_to_dsp(val));
 
562
                if (i < 6)
 
563
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i+16]);
 
564
                else
 
565
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i+16] * 4);
 
566
        }
 
567
        else if (i < 4)
 
568
                dau_set_val_noflags(i, val);
 
569
        else
 
570
                dau_write_pi_special(i, val);
 
571
}
 
572
 
 
573
 
 
574
inline void dsp32c_device::dau_write_pi_4bytes(int pi, UINT32 val)
 
575
{
 
576
        int p = (pi >> 3) & 15;
 
577
        int i = (pi >> 0) & 7;
 
578
 
 
579
        if (p == 15) p = m_lastp;               // P=15 means Z inherits from Y, Y inherits from X
 
580
        if (p)
 
581
        {
 
582
                m_lastp = p;
 
583
                WLONG_DEFERRED(m_r[p], val);
 
584
                if (i < 6)
 
585
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i+16]);
 
586
                else
 
587
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i+16] * 4);
 
588
        }
 
589
        else if (i < 4)
 
590
                dau_set_val_noflags(i, dsp_to_double(val));
 
591
        else
 
592
                dau_write_pi_special(i, val);
 
593
}
 
594
 
 
595
 
 
596
inline void dsp32c_device::dau_write_pi_2bytes(int pi, UINT16 val)
 
597
{
 
598
        int p = (pi >> 3) & 15;
 
599
        int i = (pi >> 0) & 7;
 
600
 
 
601
        if (p == 15) p = m_lastp;               // P=15 means Z inherits from Y, Y inherits from X
 
602
        if (p)
 
603
        {
 
604
                m_lastp = p;
 
605
                WWORD_DEFERRED(m_r[p], val);
 
606
                if (i < 6)
 
607
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i+16]);
 
608
                else
 
609
                        m_r[p] = TRUNCATE24(m_r[p] + m_r[i+16] * 2);
 
610
        }
 
611
        else if (i < 4)
 
612
                dau_set_val_noflags(i, dsp_to_double(val << 16));
 
613
        else
 
614
                dau_write_pi_special(i, val);
 
615
}
 
616
 
 
617
 
 
618
 
 
619
//**************************************************************************
 
620
//  COMMON CONDITION ROUTINE
 
621
//**************************************************************************
602
622
 
603
623
#if (!ASSUME_UNCONDITIONAL_CAU)
604
 
static int condition(dsp32_state *cpustate, int cond)
 
624
int dsp32c_device::condition(int cond)
605
625
{
606
626
        switch (cond)
607
627
        {
639
659
                        return (cFLAG | zFLAG);
640
660
 
641
661
                case 16:
642
 
                        return !(DEFERRED_VUFLAGS(cpustate) & UFLAGBIT);
 
662
                        return !(DEFERRED_VUFLAGS() & UFLAGBIT);
643
663
                case 17:
644
 
                        return (DEFERRED_VUFLAGS(cpustate) & UFLAGBIT);
 
664
                        return (DEFERRED_VUFLAGS() & UFLAGBIT);
645
665
                case 18:
646
 
                        return !(DEFERRED_NZFLAGS(cpustate) < 0);
 
666
                        return !(DEFERRED_NZFLAGS() < 0);
647
667
                case 19:
648
 
                        return (DEFERRED_NZFLAGS(cpustate) < 0);
 
668
                        return (DEFERRED_NZFLAGS() < 0);
649
669
                case 20:
650
 
                        return !(DEFERRED_NZFLAGS(cpustate) == 0);
 
670
                        return !(DEFERRED_NZFLAGS() == 0);
651
671
                case 21:
652
 
                        return (DEFERRED_NZFLAGS(cpustate) == 0);
 
672
                        return (DEFERRED_NZFLAGS() == 0);
653
673
                case 22:
654
 
                        return !(DEFERRED_VUFLAGS(cpustate) & VFLAGBIT);
 
674
                        return !(DEFERRED_VUFLAGS() & VFLAGBIT);
655
675
                case 23:
656
 
                        return (DEFERRED_VUFLAGS(cpustate) & VFLAGBIT);
 
676
                        return (DEFERRED_VUFLAGS() & VFLAGBIT);
657
677
                case 24:
658
 
                        return !(DEFERRED_NZFLAGS(cpustate) <= 0);
 
678
                        return !(DEFERRED_NZFLAGS() <= 0);
659
679
                case 25:
660
 
                        return (DEFERRED_NZFLAGS(cpustate) <= 0);
 
680
                        return (DEFERRED_NZFLAGS() <= 0);
661
681
 
662
 
                case 32:        /* !ibf */
663
 
                case 33:        /* ibf */
664
 
                case 34:        /* !obe */
665
 
                case 35:        /* obe */
666
 
                case 36:        /* !pdf */
667
 
                case 37:        /* pdf */
668
 
                case 38:        /* !pif */
669
 
                case 39:        /* pif */
670
 
                case 40:        /* !sy */
671
 
                case 41:        /* sy */
672
 
                case 42:        /* !fb */
673
 
                case 43:        /* fb */
674
 
                case 44:        /* !ireq1 */
675
 
                case 45:        /* ireq1 */
676
 
                case 46:        /* !ireq2 */
677
 
                case 47:        /* ireq2 */
 
682
                case 32:        // !ibf
 
683
                case 33:        // ibf
 
684
                case 34:        // !obe
 
685
                case 35:        // obe
 
686
                case 36:        // !pdf
 
687
                case 37:        // pdf
 
688
                case 38:        // !pif
 
689
                case 39:        // pif
 
690
                case 40:        // !sy
 
691
                case 41:        // sy
 
692
                case 42:        // !fb
 
693
                case 43:        // fb
 
694
                case 44:        // !ireq1
 
695
                case 45:        // ireq1
 
696
                case 46:        // !ireq2
 
697
                case 47:        // ireq2
678
698
                default:
679
699
                    fatalerror("Unimplemented condition: %X", cond);
680
700
        }
683
703
 
684
704
 
685
705
 
686
 
/***************************************************************************
687
 
    CAU BRANCH INSTRUCTION IMPLEMENTATION
688
 
***************************************************************************/
 
706
//**************************************************************************
 
707
//  CAU BRANCH INSTRUCTION IMPLEMENTATION
 
708
//**************************************************************************
689
709
 
690
 
static void nop(dsp32_state *cpustate, UINT32 op)
 
710
void dsp32c_device::nop(UINT32 op)
691
711
{
692
712
        if (op == 0)
693
713
                return;
694
 
        execute_one(cpustate);
695
 
        cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
 
714
        execute_one();
 
715
        PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
696
716
}
697
717
 
698
718
 
699
 
static void goto_t(dsp32_state *cpustate, UINT32 op)
 
719
void dsp32c_device::goto_t(UINT32 op)
700
720
{
701
 
        execute_one(cpustate);
702
 
        cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
 
721
        execute_one();
 
722
        PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
703
723
}
704
724
 
705
725
 
706
 
static void goto_pl(dsp32_state *cpustate, UINT32 op)
 
726
void dsp32c_device::goto_pl(UINT32 op)
707
727
{
708
728
        if (!nFLAG)
709
729
        {
710
 
                execute_one(cpustate);
711
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
 
730
                execute_one();
 
731
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
712
732
        }
713
733
}
714
734
 
715
735
 
716
 
static void goto_mi(dsp32_state *cpustate, UINT32 op)
 
736
void dsp32c_device::goto_mi(UINT32 op)
717
737
{
718
738
        if (nFLAG)
719
739
        {
720
 
                execute_one(cpustate);
721
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
 
740
                execute_one();
 
741
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
722
742
        }
723
743
}
724
744
 
725
745
 
726
 
static void goto_ne(dsp32_state *cpustate, UINT32 op)
 
746
void dsp32c_device::goto_ne(UINT32 op)
727
747
{
728
748
        if (!zFLAG)
729
749
        {
730
 
                execute_one(cpustate);
731
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
 
750
                execute_one();
 
751
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
732
752
        }
733
753
}
734
754
 
735
755
 
736
 
static void goto_eq(dsp32_state *cpustate, UINT32 op)
 
756
void dsp32c_device::goto_eq(UINT32 op)
737
757
{
738
758
        if (zFLAG)
739
759
        {
740
 
                execute_one(cpustate);
741
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
 
760
                execute_one();
 
761
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
742
762
        }
743
763
}
744
764
 
745
765
 
746
 
static void goto_vc(dsp32_state *cpustate, UINT32 op)
 
766
void dsp32c_device::goto_vc(UINT32 op)
747
767
{
748
768
        if (!vFLAG)
749
769
        {
750
 
                execute_one(cpustate);
751
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
 
770
                execute_one();
 
771
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
752
772
        }
753
773
}
754
774
 
755
775
 
756
 
static void goto_vs(dsp32_state *cpustate, UINT32 op)
 
776
void dsp32c_device::goto_vs(UINT32 op)
757
777
{
758
778
        if (vFLAG)
759
779
        {
760
 
                execute_one(cpustate);
761
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
 
780
                execute_one();
 
781
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
762
782
        }
763
783
}
764
784
 
765
785
 
766
 
static void goto_cc(dsp32_state *cpustate, UINT32 op)
 
786
void dsp32c_device::goto_cc(UINT32 op)
767
787
{
768
788
        if (!cFLAG)
769
789
        {
770
 
                execute_one(cpustate);
771
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
 
790
                execute_one();
 
791
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
772
792
        }
773
793
}
774
794
 
775
795
 
776
 
static void goto_cs(dsp32_state *cpustate, UINT32 op)
 
796
void dsp32c_device::goto_cs(UINT32 op)
777
797
{
778
798
        if (cFLAG)
779
799
        {
780
 
                execute_one(cpustate);
781
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
 
800
                execute_one();
 
801
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
782
802
        }
783
803
}
784
804
 
785
805
 
786
 
static void goto_ge(dsp32_state *cpustate, UINT32 op)
 
806
void dsp32c_device::goto_ge(UINT32 op)
787
807
{
788
808
        if (!(nFLAG ^ vFLAG))
789
809
        {
790
 
                execute_one(cpustate);
791
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
 
810
                execute_one();
 
811
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
792
812
        }
793
813
}
794
814
 
795
815
 
796
 
static void goto_lt(dsp32_state *cpustate, UINT32 op)
 
816
void dsp32c_device::goto_lt(UINT32 op)
797
817
{
798
818
        if (nFLAG ^ vFLAG)
799
819
        {
800
 
                execute_one(cpustate);
801
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
 
820
                execute_one();
 
821
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
802
822
        }
803
823
}
804
824
 
805
825
 
806
 
static void goto_gt(dsp32_state *cpustate, UINT32 op)
 
826
void dsp32c_device::goto_gt(UINT32 op)
807
827
{
808
828
        if (!(zFLAG | (nFLAG ^ vFLAG)))
809
829
        {
810
 
                execute_one(cpustate);
811
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
 
830
                execute_one();
 
831
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
812
832
        }
813
833
}
814
834
 
815
835
 
816
 
static void goto_le(dsp32_state *cpustate, UINT32 op)
 
836
void dsp32c_device::goto_le(UINT32 op)
817
837
{
818
838
        if (zFLAG | (nFLAG ^ vFLAG))
819
839
        {
820
 
                execute_one(cpustate);
821
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
 
840
                execute_one();
 
841
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
822
842
        }
823
843
}
824
844
 
825
845
 
826
 
static void goto_hi(dsp32_state *cpustate, UINT32 op)
 
846
void dsp32c_device::goto_hi(UINT32 op)
827
847
{
828
848
        if (!cFLAG && !zFLAG)
829
849
        {
830
 
                execute_one(cpustate);
831
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
 
850
                execute_one();
 
851
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
832
852
        }
833
853
}
834
854
 
835
855
 
836
 
static void goto_ls(dsp32_state *cpustate, UINT32 op)
 
856
void dsp32c_device::goto_ls(UINT32 op)
837
857
{
838
858
        if (cFLAG || zFLAG)
839
859
        {
840
 
                execute_one(cpustate);
841
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
842
 
        }
843
 
}
844
 
 
845
 
 
846
 
static void goto_auc(dsp32_state *cpustate, UINT32 op)
847
 
{
848
 
        if (!(DEFERRED_VUFLAGS(cpustate) & UFLAGBIT))
849
 
        {
850
 
                execute_one(cpustate);
851
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
852
 
        }
853
 
}
854
 
 
855
 
 
856
 
static void goto_aus(dsp32_state *cpustate, UINT32 op)
857
 
{
858
 
        if (DEFERRED_VUFLAGS(cpustate) & UFLAGBIT)
859
 
        {
860
 
                execute_one(cpustate);
861
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
862
 
        }
863
 
}
864
 
 
865
 
 
866
 
static void goto_age(dsp32_state *cpustate, UINT32 op)
867
 
{
868
 
        if (DEFERRED_NZFLAGS(cpustate) >= 0)
869
 
        {
870
 
                execute_one(cpustate);
871
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
872
 
        }
873
 
}
874
 
 
875
 
 
876
 
static void goto_alt(dsp32_state *cpustate, UINT32 op)
877
 
{
878
 
        if (DEFERRED_NZFLAGS(cpustate) < 0)
879
 
        {
880
 
                execute_one(cpustate);
881
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
882
 
        }
883
 
}
884
 
 
885
 
 
886
 
static void goto_ane(dsp32_state *cpustate, UINT32 op)
887
 
{
888
 
        if (DEFERRED_NZFLAGS(cpustate) != 0)
889
 
        {
890
 
                execute_one(cpustate);
891
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
892
 
        }
893
 
}
894
 
 
895
 
 
896
 
static void goto_aeq(dsp32_state *cpustate, UINT32 op)
897
 
{
898
 
        if (DEFERRED_NZFLAGS(cpustate) == 0)
899
 
        {
900
 
                execute_one(cpustate);
901
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
902
 
        }
903
 
}
904
 
 
905
 
 
906
 
static void goto_avc(dsp32_state *cpustate, UINT32 op)
907
 
{
908
 
        if (!(DEFERRED_VUFLAGS(cpustate) & VFLAGBIT))
909
 
        {
910
 
                execute_one(cpustate);
911
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
912
 
        }
913
 
}
914
 
 
915
 
 
916
 
static void goto_avs(dsp32_state *cpustate, UINT32 op)
917
 
{
918
 
        if (DEFERRED_VUFLAGS(cpustate) & VFLAGBIT)
919
 
        {
920
 
                execute_one(cpustate);
921
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
922
 
        }
923
 
}
924
 
 
925
 
 
926
 
static void goto_agt(dsp32_state *cpustate, UINT32 op)
927
 
{
928
 
        if (DEFERRED_NZFLAGS(cpustate) > 0)
929
 
        {
930
 
                execute_one(cpustate);
931
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
932
 
        }
933
 
}
934
 
 
935
 
 
936
 
static void goto_ale(dsp32_state *cpustate, UINT32 op)
937
 
{
938
 
        if (DEFERRED_NZFLAGS(cpustate) <= 0)
939
 
        {
940
 
                execute_one(cpustate);
941
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
942
 
        }
943
 
}
944
 
 
945
 
 
946
 
static void goto_ibe(dsp32_state *cpustate, UINT32 op)
947
 
{
948
 
        unimplemented(cpustate, op);
949
 
}
950
 
 
951
 
 
952
 
static void goto_ibf(dsp32_state *cpustate, UINT32 op)
953
 
{
954
 
        unimplemented(cpustate, op);
955
 
}
956
 
 
957
 
 
958
 
static void goto_obf(dsp32_state *cpustate, UINT32 op)
959
 
{
960
 
        unimplemented(cpustate, op);
961
 
}
962
 
 
963
 
 
964
 
static void goto_obe(dsp32_state *cpustate, UINT32 op)
965
 
{
966
 
        unimplemented(cpustate, op);
967
 
}
968
 
 
969
 
 
970
 
static void goto_pde(dsp32_state *cpustate, UINT32 op)
971
 
{
972
 
        unimplemented(cpustate, op);
973
 
}
974
 
 
975
 
 
976
 
static void goto_pdf(dsp32_state *cpustate, UINT32 op)
977
 
{
978
 
        unimplemented(cpustate, op);
979
 
}
980
 
 
981
 
 
982
 
static void goto_pie(dsp32_state *cpustate, UINT32 op)
983
 
{
984
 
        unimplemented(cpustate, op);
985
 
}
986
 
 
987
 
 
988
 
static void goto_pif(dsp32_state *cpustate, UINT32 op)
989
 
{
990
 
        unimplemented(cpustate, op);
991
 
}
992
 
 
993
 
 
994
 
static void goto_syc(dsp32_state *cpustate, UINT32 op)
995
 
{
996
 
        unimplemented(cpustate, op);
997
 
}
998
 
 
999
 
 
1000
 
static void goto_sys(dsp32_state *cpustate, UINT32 op)
1001
 
{
1002
 
        unimplemented(cpustate, op);
1003
 
}
1004
 
 
1005
 
 
1006
 
static void goto_fbc(dsp32_state *cpustate, UINT32 op)
1007
 
{
1008
 
        unimplemented(cpustate, op);
1009
 
}
1010
 
 
1011
 
 
1012
 
static void goto_fbs(dsp32_state *cpustate, UINT32 op)
1013
 
{
1014
 
        unimplemented(cpustate, op);
1015
 
}
1016
 
 
1017
 
 
1018
 
static void goto_irq1lo(dsp32_state *cpustate, UINT32 op)
1019
 
{
1020
 
        unimplemented(cpustate, op);
1021
 
}
1022
 
 
1023
 
 
1024
 
static void goto_irq1hi(dsp32_state *cpustate, UINT32 op)
1025
 
{
1026
 
        unimplemented(cpustate, op);
1027
 
}
1028
 
 
1029
 
 
1030
 
static void goto_irq2lo(dsp32_state *cpustate, UINT32 op)
1031
 
{
1032
 
        unimplemented(cpustate, op);
1033
 
}
1034
 
 
1035
 
 
1036
 
static void goto_irq2hi(dsp32_state *cpustate, UINT32 op)
1037
 
{
1038
 
        unimplemented(cpustate, op);
1039
 
}
1040
 
 
1041
 
 
1042
 
static void dec_goto(dsp32_state *cpustate, UINT32 op)
 
860
                execute_one();
 
861
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
 
862
        }
 
863
}
 
864
 
 
865
 
 
866
void dsp32c_device::goto_auc(UINT32 op)
 
867
{
 
868
        if (!(DEFERRED_VUFLAGS() & UFLAGBIT))
 
869
        {
 
870
                execute_one();
 
871
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
 
872
        }
 
873
}
 
874
 
 
875
 
 
876
void dsp32c_device::goto_aus(UINT32 op)
 
877
{
 
878
        if (DEFERRED_VUFLAGS() & UFLAGBIT)
 
879
        {
 
880
                execute_one();
 
881
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
 
882
        }
 
883
}
 
884
 
 
885
 
 
886
void dsp32c_device::goto_age(UINT32 op)
 
887
{
 
888
        if (DEFERRED_NZFLAGS() >= 0)
 
889
        {
 
890
                execute_one();
 
891
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
 
892
        }
 
893
}
 
894
 
 
895
 
 
896
void dsp32c_device::goto_alt(UINT32 op)
 
897
{
 
898
        if (DEFERRED_NZFLAGS() < 0)
 
899
        {
 
900
                execute_one();
 
901
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
 
902
        }
 
903
}
 
904
 
 
905
 
 
906
void dsp32c_device::goto_ane(UINT32 op)
 
907
{
 
908
        if (DEFERRED_NZFLAGS() != 0)
 
909
        {
 
910
                execute_one();
 
911
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
 
912
        }
 
913
}
 
914
 
 
915
 
 
916
void dsp32c_device::goto_aeq(UINT32 op)
 
917
{
 
918
        if (DEFERRED_NZFLAGS() == 0)
 
919
        {
 
920
                execute_one();
 
921
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
 
922
        }
 
923
}
 
924
 
 
925
 
 
926
void dsp32c_device::goto_avc(UINT32 op)
 
927
{
 
928
        if (!(DEFERRED_VUFLAGS() & VFLAGBIT))
 
929
        {
 
930
                execute_one();
 
931
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
 
932
        }
 
933
}
 
934
 
 
935
 
 
936
void dsp32c_device::goto_avs(UINT32 op)
 
937
{
 
938
        if (DEFERRED_VUFLAGS() & VFLAGBIT)
 
939
        {
 
940
                execute_one();
 
941
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
 
942
        }
 
943
}
 
944
 
 
945
 
 
946
void dsp32c_device::goto_agt(UINT32 op)
 
947
{
 
948
        if (DEFERRED_NZFLAGS() > 0)
 
949
        {
 
950
                execute_one();
 
951
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
 
952
        }
 
953
}
 
954
 
 
955
 
 
956
void dsp32c_device::goto_ale(UINT32 op)
 
957
{
 
958
        if (DEFERRED_NZFLAGS() <= 0)
 
959
        {
 
960
                execute_one();
 
961
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
 
962
        }
 
963
}
 
964
 
 
965
 
 
966
void dsp32c_device::goto_ibe(UINT32 op)
 
967
{
 
968
        unimplemented(op);
 
969
}
 
970
 
 
971
 
 
972
void dsp32c_device::goto_ibf(UINT32 op)
 
973
{
 
974
        unimplemented(op);
 
975
}
 
976
 
 
977
 
 
978
void dsp32c_device::goto_obf(UINT32 op)
 
979
{
 
980
        unimplemented(op);
 
981
}
 
982
 
 
983
 
 
984
void dsp32c_device::goto_obe(UINT32 op)
 
985
{
 
986
        unimplemented(op);
 
987
}
 
988
 
 
989
 
 
990
void dsp32c_device::goto_pde(UINT32 op)
 
991
{
 
992
        unimplemented(op);
 
993
}
 
994
 
 
995
 
 
996
void dsp32c_device::goto_pdf(UINT32 op)
 
997
{
 
998
        unimplemented(op);
 
999
}
 
1000
 
 
1001
 
 
1002
void dsp32c_device::goto_pie(UINT32 op)
 
1003
{
 
1004
        unimplemented(op);
 
1005
}
 
1006
 
 
1007
 
 
1008
void dsp32c_device::goto_pif(UINT32 op)
 
1009
{
 
1010
        unimplemented(op);
 
1011
}
 
1012
 
 
1013
 
 
1014
void dsp32c_device::goto_syc(UINT32 op)
 
1015
{
 
1016
        unimplemented(op);
 
1017
}
 
1018
 
 
1019
 
 
1020
void dsp32c_device::goto_sys(UINT32 op)
 
1021
{
 
1022
        unimplemented(op);
 
1023
}
 
1024
 
 
1025
 
 
1026
void dsp32c_device::goto_fbc(UINT32 op)
 
1027
{
 
1028
        unimplemented(op);
 
1029
}
 
1030
 
 
1031
 
 
1032
void dsp32c_device::goto_fbs(UINT32 op)
 
1033
{
 
1034
        unimplemented(op);
 
1035
}
 
1036
 
 
1037
 
 
1038
void dsp32c_device::goto_irq1lo(UINT32 op)
 
1039
{
 
1040
        unimplemented(op);
 
1041
}
 
1042
 
 
1043
 
 
1044
void dsp32c_device::goto_irq1hi(UINT32 op)
 
1045
{
 
1046
        unimplemented(op);
 
1047
}
 
1048
 
 
1049
 
 
1050
void dsp32c_device::goto_irq2lo(UINT32 op)
 
1051
{
 
1052
        unimplemented(op);
 
1053
}
 
1054
 
 
1055
 
 
1056
void dsp32c_device::goto_irq2hi(UINT32 op)
 
1057
{
 
1058
        unimplemented(op);
 
1059
}
 
1060
 
 
1061
 
 
1062
void dsp32c_device::dec_goto(UINT32 op)
1043
1063
{
1044
1064
        int hr = (op >> 21) & 0x1f;
1045
 
        int old = (INT16)cpustate->r[hr];
1046
 
        cpustate->r[hr] = EXTEND16_TO_24(cpustate->r[hr] - 1);
 
1065
        int old = (INT16)m_r[hr];
 
1066
        m_r[hr] = EXTEND16_TO_24(m_r[hr] - 1);
1047
1067
        if (old >= 0)
1048
1068
        {
1049
 
                execute_one(cpustate);
1050
 
                cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
 
1069
                execute_one();
 
1070
                PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
1051
1071
        }
1052
1072
}
1053
1073
 
1054
1074
 
1055
 
static void call(dsp32_state *cpustate, UINT32 op)
 
1075
void dsp32c_device::call(UINT32 op)
1056
1076
{
1057
1077
        int mr = (op >> 21) & 0x1f;
1058
1078
        if (IS_WRITEABLE(mr))
1059
 
                cpustate->r[mr] = cpustate->PC + 4;
1060
 
        execute_one(cpustate);
1061
 
        cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (INT16)op);
 
1079
                m_r[mr] = PC + 4;
 
1080
        execute_one();
 
1081
        PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (INT16)op);
1062
1082
}
1063
1083
 
1064
1084
 
1065
 
static void goto24(dsp32_state *cpustate, UINT32 op)
 
1085
void dsp32c_device::goto24(UINT32 op)
1066
1086
{
1067
 
        execute_one(cpustate);
1068
 
        cpustate->PC = TRUNCATE24(REG24(cpustate, (op >> 16) & 0x1f) + (op & 0xffff) + ((op >> 5) & 0xff0000));
 
1087
        execute_one();
 
1088
        PC = TRUNCATE24(REG24((op >> 16) & 0x1f) + (op & 0xffff) + ((op >> 5) & 0xff0000));
1069
1089
}
1070
1090
 
1071
1091
 
1072
 
static void call24(dsp32_state *cpustate, UINT32 op)
 
1092
void dsp32c_device::call24(UINT32 op)
1073
1093
{
1074
1094
        int mr = (op >> 16) & 0x1f;
1075
1095
        if (IS_WRITEABLE(mr))
1076
 
                cpustate->r[mr] = cpustate->PC + 4;
1077
 
        execute_one(cpustate);
1078
 
        cpustate->PC = (op & 0xffff) + ((op >> 5) & 0xff0000);
1079
 
}
1080
 
 
1081
 
 
1082
 
static void do_i(dsp32_state *cpustate, UINT32 op)
1083
 
{
1084
 
        unimplemented(cpustate, op);
1085
 
}
1086
 
 
1087
 
 
1088
 
static void do_r(dsp32_state *cpustate, UINT32 op)
1089
 
{
1090
 
        unimplemented(cpustate, op);
1091
 
}
1092
 
 
1093
 
 
1094
 
 
1095
 
/***************************************************************************
1096
 
    CAU 16-BIT ARITHMETIC IMPLEMENTATION
1097
 
***************************************************************************/
1098
 
 
1099
 
static void add_si(dsp32_state *cpustate, UINT32 op)
 
1096
                m_r[mr] = PC + 4;
 
1097
        execute_one();
 
1098
        PC = (op & 0xffff) + ((op >> 5) & 0xff0000);
 
1099
}
 
1100
 
 
1101
 
 
1102
void dsp32c_device::do_i(UINT32 op)
 
1103
{
 
1104
        unimplemented(op);
 
1105
}
 
1106
 
 
1107
 
 
1108
void dsp32c_device::do_r(UINT32 op)
 
1109
{
 
1110
        unimplemented(op);
 
1111
}
 
1112
 
 
1113
 
 
1114
 
 
1115
//**************************************************************************
 
1116
//  CAU 16-BIT ARITHMETIC IMPLEMENTATION
 
1117
//**************************************************************************
 
1118
 
 
1119
void dsp32c_device::add_si(UINT32 op)
1100
1120
{
1101
1121
        int dr = (op >> 21) & 0x1f;
1102
 
        int hrval = REG16(cpustate, (op >> 16) & 0x1f);
 
1122
        int hrval = REG16((op >> 16) & 0x1f);
1103
1123
        int res = hrval + (UINT16)op;
1104
1124
        if (IS_WRITEABLE(dr))
1105
 
                cpustate->r[dr] = EXTEND16_TO_24(res);
1106
 
        SET_NZCV_16(cpustate, hrval, op, res);
 
1125
                m_r[dr] = EXTEND16_TO_24(res);
 
1126
        SET_NZCV_16(hrval, op, res);
1107
1127
}
1108
1128
 
1109
1129
 
1110
 
static void add_ss(dsp32_state *cpustate, UINT32 op)
 
1130
void dsp32c_device::add_ss(UINT32 op)
1111
1131
{
1112
 
        if (CONDITION_IS_TRUE(cpustate))
 
1132
        if (CONDITION_IS_TRUE())
1113
1133
        {
1114
1134
                int dr = (op >> 16) & 0x1f;
1115
 
                int s1rval = REG16(cpustate, (op >> 5) & 0x1f);
1116
 
                int s2rval = (op & 0x800) ? REG16(cpustate, (op >> 0) & 0x1f) : REG16(cpustate, dr);
 
1135
                int s1rval = REG16((op >> 5) & 0x1f);
 
1136
                int s2rval = (op & 0x800) ? REG16((op >> 0) & 0x1f) : REG16(dr);
1117
1137
                int res = s2rval + s1rval;
1118
1138
                if (IS_WRITEABLE(dr))
1119
 
                        cpustate->r[dr] = EXTEND16_TO_24(res);
1120
 
                SET_NZCV_16(cpustate, s1rval, s2rval, res);
 
1139
                        m_r[dr] = EXTEND16_TO_24(res);
 
1140
                SET_NZCV_16(s1rval, s2rval, res);
1121
1141
        }
1122
1142
}
1123
1143
 
1124
1144
 
1125
 
static void mul2_s(dsp32_state *cpustate, UINT32 op)
 
1145
void dsp32c_device::mul2_s(UINT32 op)
1126
1146
{
1127
 
        if (CONDITION_IS_TRUE(cpustate))
 
1147
        if (CONDITION_IS_TRUE())
1128
1148
        {
1129
1149
                int dr = (op >> 16) & 0x1f;
1130
 
                int s1rval = REG16(cpustate, (op >> 5) & 0x1f);
 
1150
                int s1rval = REG16((op >> 5) & 0x1f);
1131
1151
                int res = s1rval * 2;
1132
1152
                if (IS_WRITEABLE(dr))
1133
 
                        cpustate->r[dr] = EXTEND16_TO_24(res);
1134
 
                SET_NZCV_16(cpustate, s1rval, 0, res);
 
1153
                        m_r[dr] = EXTEND16_TO_24(res);
 
1154
                SET_NZCV_16(s1rval, 0, res);
1135
1155
        }
1136
1156
}
1137
1157
 
1138
1158
 
1139
 
static void subr_ss(dsp32_state *cpustate, UINT32 op)
 
1159
void dsp32c_device::subr_ss(UINT32 op)
1140
1160
{
1141
 
        if (CONDITION_IS_TRUE(cpustate))
 
1161
        if (CONDITION_IS_TRUE())
1142
1162
        {
1143
1163
                int dr = (op >> 16) & 0x1f;
1144
 
                int s1rval = REG16(cpustate, (op >> 5) & 0x1f);
1145
 
                int s2rval = (op & 0x800) ? REG16(cpustate, (op >> 0) & 0x1f) : REG16(cpustate, dr);
 
1164
                int s1rval = REG16((op >> 5) & 0x1f);
 
1165
                int s2rval = (op & 0x800) ? REG16((op >> 0) & 0x1f) : REG16(dr);
1146
1166
                int res = s1rval - s2rval;
1147
1167
                if (IS_WRITEABLE(dr))
1148
 
                        cpustate->r[dr] = EXTEND16_TO_24(res);
1149
 
                SET_NZCV_16(cpustate, s1rval, s2rval, res);
 
1168
                        m_r[dr] = EXTEND16_TO_24(res);
 
1169
                SET_NZCV_16(s1rval, s2rval, res);
1150
1170
        }
1151
1171
}
1152
1172
 
1153
1173
 
1154
 
static void addr_ss(dsp32_state *cpustate, UINT32 op)
 
1174
void dsp32c_device::addr_ss(UINT32 op)
1155
1175
{
1156
 
        unimplemented(cpustate, op);
 
1176
        unimplemented(op);
1157
1177
}
1158
1178
 
1159
1179
 
1160
 
static void sub_ss(dsp32_state *cpustate, UINT32 op)
 
1180
void dsp32c_device::sub_ss(UINT32 op)
1161
1181
{
1162
 
        if (CONDITION_IS_TRUE(cpustate))
 
1182
        if (CONDITION_IS_TRUE())
1163
1183
        {
1164
1184
                int dr = (op >> 16) & 0x1f;
1165
 
                int s1rval = REG16(cpustate, (op >> 5) & 0x1f);
1166
 
                int s2rval = (op & 0x800) ? REG16(cpustate, (op >> 0) & 0x1f) : REG16(cpustate, dr);
 
1185
                int s1rval = REG16((op >> 5) & 0x1f);
 
1186
                int s2rval = (op & 0x800) ? REG16((op >> 0) & 0x1f) : REG16(dr);
1167
1187
                int res = s2rval - s1rval;
1168
1188
                if (IS_WRITEABLE(dr))
1169
 
                        cpustate->r[dr] = EXTEND16_TO_24(res);
1170
 
                SET_NZCV_16(cpustate, s1rval, s2rval, res);
 
1189
                        m_r[dr] = EXTEND16_TO_24(res);
 
1190
                SET_NZCV_16(s1rval, s2rval, res);
1171
1191
        }
1172
1192
}
1173
1193
 
1174
1194
 
1175
 
static void neg_s(dsp32_state *cpustate, UINT32 op)
 
1195
void dsp32c_device::neg_s(UINT32 op)
1176
1196
{
1177
 
        if (CONDITION_IS_TRUE(cpustate))
 
1197
        if (CONDITION_IS_TRUE())
1178
1198
        {
1179
1199
                int dr = (op >> 16) & 0x1f;
1180
 
                int s1rval = REG16(cpustate, (op >> 5) & 0x1f);
 
1200
                int s1rval = REG16((op >> 5) & 0x1f);
1181
1201
                int res = -s1rval;
1182
1202
                if (IS_WRITEABLE(dr))
1183
 
                        cpustate->r[dr] = EXTEND16_TO_24(res);
1184
 
                SET_NZCV_16(cpustate, s1rval, 0, res);
 
1203
                        m_r[dr] = EXTEND16_TO_24(res);
 
1204
                SET_NZCV_16(s1rval, 0, res);
1185
1205
        }
1186
1206
}
1187
1207
 
1188
1208
 
1189
 
static void andc_ss(dsp32_state *cpustate, UINT32 op)
 
1209
void dsp32c_device::andc_ss(UINT32 op)
1190
1210
{
1191
 
        if (CONDITION_IS_TRUE(cpustate))
 
1211
        if (CONDITION_IS_TRUE())
1192
1212
        {
1193
1213
                int dr = (op >> 16) & 0x1f;
1194
 
                int s1rval = REG16(cpustate, (op >> 5) & 0x1f);
1195
 
                int s2rval = (op & 0x800) ? REG16(cpustate, (op >> 0) & 0x1f) : REG16(cpustate, dr);
 
1214
                int s1rval = REG16((op >> 5) & 0x1f);
 
1215
                int s2rval = (op & 0x800) ? REG16((op >> 0) & 0x1f) : REG16(dr);
1196
1216
                int res = s2rval & ~s1rval;
1197
1217
                if (IS_WRITEABLE(dr))
1198
 
                        cpustate->r[dr] = EXTEND16_TO_24(res);
1199
 
                SET_NZ00_16(cpustate, res);
 
1218
                        m_r[dr] = EXTEND16_TO_24(res);
 
1219
                SET_NZ00_16(res);
1200
1220
        }
1201
1221
}
1202
1222
 
1203
1223
 
1204
 
static void cmp_ss(dsp32_state *cpustate, UINT32 op)
 
1224
void dsp32c_device::cmp_ss(UINT32 op)
1205
1225
{
1206
 
        if (CONDITION_IS_TRUE(cpustate))
 
1226
        if (CONDITION_IS_TRUE())
1207
1227
        {
1208
 
                int drval = REG16(cpustate, (op >> 16) & 0x1f);
1209
 
                int s1rval = REG16(cpustate, (op >> 5) & 0x1f);
 
1228
                int drval = REG16((op >> 16) & 0x1f);
 
1229
                int s1rval = REG16((op >> 5) & 0x1f);
1210
1230
                int res = drval - s1rval;
1211
 
                SET_NZCV_16(cpustate, drval, s1rval, res);
 
1231
                SET_NZCV_16(drval, s1rval, res);
1212
1232
        }
1213
1233
}
1214
1234
 
1215
1235
 
1216
 
static void xor_ss(dsp32_state *cpustate, UINT32 op)
 
1236
void dsp32c_device::xor_ss(UINT32 op)
1217
1237
{
1218
 
        if (CONDITION_IS_TRUE(cpustate))
 
1238
        if (CONDITION_IS_TRUE())
1219
1239
        {
1220
1240
                int dr = (op >> 16) & 0x1f;
1221
 
                int s1rval = REG16(cpustate, (op >> 5) & 0x1f);
1222
 
                int s2rval = (op & 0x800) ? REG16(cpustate, (op >> 0) & 0x1f) : REG16(cpustate, dr);
 
1241
                int s1rval = REG16((op >> 5) & 0x1f);
 
1242
                int s2rval = (op & 0x800) ? REG16((op >> 0) & 0x1f) : REG16(dr);
1223
1243
                int res = s2rval ^ s1rval;
1224
1244
                if (IS_WRITEABLE(dr))
1225
 
                        cpustate->r[dr] = EXTEND16_TO_24(res);
1226
 
                SET_NZ00_16(cpustate, res);
 
1245
                        m_r[dr] = EXTEND16_TO_24(res);
 
1246
                SET_NZ00_16(res);
1227
1247
        }
1228
1248
}
1229
1249
 
1230
1250
 
1231
 
static void rcr_s(dsp32_state *cpustate, UINT32 op)
 
1251
void dsp32c_device::rcr_s(UINT32 op)
1232
1252
{
1233
 
        if (CONDITION_IS_TRUE(cpustate))
 
1253
        if (CONDITION_IS_TRUE())
1234
1254
        {
1235
1255
                int dr = (op >> 16) & 0x1f;
1236
 
                int s1rval = REG16(cpustate, (op >> 5) & 0x1f);
1237
 
                int res = ((cpustate->nzcflags >> 9) & 0x8000) | (s1rval >> 1);
 
1256
                int s1rval = REG16((op >> 5) & 0x1f);
 
1257
                int res = ((m_nzcflags >> 9) & 0x8000) | (s1rval >> 1);
1238
1258
                if (IS_WRITEABLE(dr))
1239
 
                        cpustate->r[dr] = EXTEND16_TO_24(res);
1240
 
                cpustate->nzcflags = ((res & 0xffff) << 8) | ((s1rval & 1) << 24);
1241
 
                cpustate->vflags = 0;
 
1259
                        m_r[dr] = EXTEND16_TO_24(res);
 
1260
                m_nzcflags = ((res & 0xffff) << 8) | ((s1rval & 1) << 24);
 
1261
                m_vflags = 0;
1242
1262
        }
1243
1263
}
1244
1264
 
1245
1265
 
1246
 
static void or_ss(dsp32_state *cpustate, UINT32 op)
 
1266
void dsp32c_device::or_ss(UINT32 op)
1247
1267
{
1248
 
        if (CONDITION_IS_TRUE(cpustate))
 
1268
        if (CONDITION_IS_TRUE())
1249
1269
        {
1250
1270
                int dr = (op >> 16) & 0x1f;
1251
 
                int s1rval = REG16(cpustate, (op >> 5) & 0x1f);
1252
 
                int s2rval = (op & 0x800) ? REG16(cpustate, (op >> 0) & 0x1f) : REG16(cpustate, dr);
 
1271
                int s1rval = REG16((op >> 5) & 0x1f);
 
1272
                int s2rval = (op & 0x800) ? REG16((op >> 0) & 0x1f) : REG16(dr);
1253
1273
                int res = s2rval | s1rval;
1254
1274
                if (IS_WRITEABLE(dr))
1255
 
                        cpustate->r[dr] = EXTEND16_TO_24(res);
1256
 
                SET_NZ00_16(cpustate, res);
 
1275
                        m_r[dr] = EXTEND16_TO_24(res);
 
1276
                SET_NZ00_16(res);
1257
1277
        }
1258
1278
}
1259
1279
 
1260
1280
 
1261
 
static void rcl_s(dsp32_state *cpustate, UINT32 op)
 
1281
void dsp32c_device::rcl_s(UINT32 op)
1262
1282
{
1263
 
        if (CONDITION_IS_TRUE(cpustate))
 
1283
        if (CONDITION_IS_TRUE())
1264
1284
        {
1265
1285
                int dr = (op >> 16) & 0x1f;
1266
 
                int s1rval = REG16(cpustate, (op >> 5) & 0x1f);
1267
 
                int res = ((cpustate->nzcflags >> 24) & 0x0001) | (s1rval << 1);
 
1286
                int s1rval = REG16((op >> 5) & 0x1f);
 
1287
                int res = ((m_nzcflags >> 24) & 0x0001) | (s1rval << 1);
1268
1288
                if (IS_WRITEABLE(dr))
1269
 
                        cpustate->r[dr] = EXTEND16_TO_24(res);
1270
 
                cpustate->nzcflags = ((res & 0xffff) << 8) | ((s1rval & 0x8000) << 9);
1271
 
                cpustate->vflags = 0;
 
1289
                        m_r[dr] = EXTEND16_TO_24(res);
 
1290
                m_nzcflags = ((res & 0xffff) << 8) | ((s1rval & 0x8000) << 9);
 
1291
                m_vflags = 0;
1272
1292
        }
1273
1293
}
1274
1294
 
1275
1295
 
1276
 
static void shr_s(dsp32_state *cpustate, UINT32 op)
 
1296
void dsp32c_device::shr_s(UINT32 op)
1277
1297
{
1278
 
        if (CONDITION_IS_TRUE(cpustate))
 
1298
        if (CONDITION_IS_TRUE())
1279
1299
        {
1280
1300
                int dr = (op >> 16) & 0x1f;
1281
 
                int s1rval = REG16(cpustate, (op >> 5) & 0x1f);
 
1301
                int s1rval = REG16((op >> 5) & 0x1f);
1282
1302
                int res = s1rval >> 1;
1283
1303
                if (IS_WRITEABLE(dr))
1284
 
                        cpustate->r[dr] = EXTEND16_TO_24(res);
1285
 
                cpustate->nzcflags = ((res & 0xffff) << 8) | ((s1rval & 1) << 24);
1286
 
                cpustate->vflags = 0;
 
1304
                        m_r[dr] = EXTEND16_TO_24(res);
 
1305
                m_nzcflags = ((res & 0xffff) << 8) | ((s1rval & 1) << 24);
 
1306
                m_vflags = 0;
1287
1307
        }
1288
1308
}
1289
1309
 
1290
1310
 
1291
 
static void div2_s(dsp32_state *cpustate, UINT32 op)
 
1311
void dsp32c_device::div2_s(UINT32 op)
1292
1312
{
1293
 
        if (CONDITION_IS_TRUE(cpustate))
 
1313
        if (CONDITION_IS_TRUE())
1294
1314
        {
1295
1315
                int dr = (op >> 16) & 0x1f;
1296
 
                int s1rval = REG16(cpustate, (op >> 5) & 0x1f);
 
1316
                int s1rval = REG16((op >> 5) & 0x1f);
1297
1317
                int res = (s1rval & 0x8000) | (s1rval >> 1);
1298
1318
                if (IS_WRITEABLE(dr))
1299
 
                        cpustate->r[dr] = EXTEND16_TO_24(res);
1300
 
                cpustate->nzcflags = ((res & 0xffff) << 8) | ((s1rval & 1) << 24);
1301
 
                cpustate->vflags = 0;
 
1319
                        m_r[dr] = EXTEND16_TO_24(res);
 
1320
                m_nzcflags = ((res & 0xffff) << 8) | ((s1rval & 1) << 24);
 
1321
                m_vflags = 0;
1302
1322
        }
1303
1323
}
1304
1324
 
1305
1325
 
1306
 
static void and_ss(dsp32_state *cpustate, UINT32 op)
 
1326
void dsp32c_device::and_ss(UINT32 op)
1307
1327
{
1308
 
        if (CONDITION_IS_TRUE(cpustate))
 
1328
        if (CONDITION_IS_TRUE())
1309
1329
        {
1310
1330
                int dr = (op >> 16) & 0x1f;
1311
 
                int s1rval = REG16(cpustate, (op >> 5) & 0x1f);
1312
 
                int s2rval = (op & 0x800) ? REG16(cpustate, (op >> 0) & 0x1f) : REG16(cpustate, dr);
 
1331
                int s1rval = REG16((op >> 5) & 0x1f);
 
1332
                int s2rval = (op & 0x800) ? REG16((op >> 0) & 0x1f) : REG16(dr);
1313
1333
                int res = s2rval & s1rval;
1314
1334
                if (IS_WRITEABLE(dr))
1315
 
                        cpustate->r[dr] = EXTEND16_TO_24(res);
1316
 
                SET_NZ00_16(cpustate, res);
 
1335
                        m_r[dr] = EXTEND16_TO_24(res);
 
1336
                SET_NZ00_16(res);
1317
1337
        }
1318
1338
}
1319
1339
 
1320
1340
 
1321
 
static void test_ss(dsp32_state *cpustate, UINT32 op)
 
1341
void dsp32c_device::test_ss(UINT32 op)
1322
1342
{
1323
 
        if (CONDITION_IS_TRUE(cpustate))
 
1343
        if (CONDITION_IS_TRUE())
1324
1344
        {
1325
 
                int drval = REG16(cpustate, (op >> 16) & 0x1f);
1326
 
                int s1rval = REG16(cpustate, (op >> 5) & 0x1f);
 
1345
                int drval = REG16((op >> 16) & 0x1f);
 
1346
                int s1rval = REG16((op >> 5) & 0x1f);
1327
1347
                int res = drval & s1rval;
1328
 
                SET_NZ00_16(cpustate, res);
 
1348
                SET_NZ00_16(res);
1329
1349
        }
1330
1350
}
1331
1351
 
1332
1352
 
1333
 
static void add_di(dsp32_state *cpustate, UINT32 op)
 
1353
void dsp32c_device::add_di(UINT32 op)
1334
1354
{
1335
1355
        int dr = (op >> 16) & 0x1f;
1336
 
        int drval = REG16(cpustate, dr);
 
1356
        int drval = REG16(dr);
1337
1357
        int res = drval + (UINT16)op;
1338
1358
        if (IS_WRITEABLE(dr))
1339
 
                cpustate->r[dr] = EXTEND16_TO_24(res);
1340
 
        SET_NZCV_16(cpustate, drval, op, res);
 
1359
                m_r[dr] = EXTEND16_TO_24(res);
 
1360
        SET_NZCV_16(drval, op, res);
1341
1361
}
1342
1362
 
1343
1363
 
1344
 
static void subr_di(dsp32_state *cpustate, UINT32 op)
 
1364
void dsp32c_device::subr_di(UINT32 op)
1345
1365
{
1346
1366
        int dr = (op >> 16) & 0x1f;
1347
 
        int drval = REG16(cpustate, dr);
 
1367
        int drval = REG16(dr);
1348
1368
        int res = (UINT16)op - drval;
1349
1369
        if (IS_WRITEABLE(dr))
1350
 
                cpustate->r[dr] = EXTEND16_TO_24(res);
1351
 
        SET_NZCV_16(cpustate, drval, op, res);
 
1370
                m_r[dr] = EXTEND16_TO_24(res);
 
1371
        SET_NZCV_16(drval, op, res);
1352
1372
}
1353
1373
 
1354
1374
 
1355
 
static void addr_di(dsp32_state *cpustate, UINT32 op)
 
1375
void dsp32c_device::addr_di(UINT32 op)
1356
1376
{
1357
 
        unimplemented(cpustate, op);
 
1377
        unimplemented(op);
1358
1378
}
1359
1379
 
1360
1380
 
1361
 
static void sub_di(dsp32_state *cpustate, UINT32 op)
 
1381
void dsp32c_device::sub_di(UINT32 op)
1362
1382
{
1363
1383
        int dr = (op >> 16) & 0x1f;
1364
 
        int drval = REG16(cpustate, dr);
 
1384
        int drval = REG16(dr);
1365
1385
        int res = drval - (UINT16)op;
1366
1386
        if (IS_WRITEABLE(dr))
1367
 
                cpustate->r[dr] = EXTEND16_TO_24(res);
1368
 
        SET_NZCV_16(cpustate, drval, op, res);
 
1387
                m_r[dr] = EXTEND16_TO_24(res);
 
1388
        SET_NZCV_16(drval, op, res);
1369
1389
}
1370
1390
 
1371
1391
 
1372
 
static void andc_di(dsp32_state *cpustate, UINT32 op)
 
1392
void dsp32c_device::andc_di(UINT32 op)
1373
1393
{
1374
1394
        int dr = (op >> 16) & 0x1f;
1375
 
        int drval = REG16(cpustate, dr);
 
1395
        int drval = REG16(dr);
1376
1396
        int res = drval & ~(UINT16)op;
1377
1397
        if (IS_WRITEABLE(dr))
1378
 
                cpustate->r[dr] = EXTEND16_TO_24(res);
1379
 
        SET_NZ00_16(cpustate, res);
 
1398
                m_r[dr] = EXTEND16_TO_24(res);
 
1399
        SET_NZ00_16(res);
1380
1400
}
1381
1401
 
1382
1402
 
1383
 
static void cmp_di(dsp32_state *cpustate, UINT32 op)
 
1403
void dsp32c_device::cmp_di(UINT32 op)
1384
1404
{
1385
 
        int drval = REG16(cpustate, (op >> 16) & 0x1f);
 
1405
        int drval = REG16((op >> 16) & 0x1f);
1386
1406
        int res = drval - (UINT16)op;
1387
 
        SET_NZCV_16(cpustate, drval, op, res);
 
1407
        SET_NZCV_16(drval, op, res);
1388
1408
}
1389
1409
 
1390
1410
 
1391
 
static void xor_di(dsp32_state *cpustate, UINT32 op)
 
1411
void dsp32c_device::xor_di(UINT32 op)
1392
1412
{
1393
1413
        int dr = (op >> 16) & 0x1f;
1394
 
        int drval = REG16(cpustate, dr);
 
1414
        int drval = REG16(dr);
1395
1415
        int res = drval ^ (UINT16)op;
1396
1416
        if (IS_WRITEABLE(dr))
1397
 
                cpustate->r[dr] = EXTEND16_TO_24(res);
1398
 
        SET_NZ00_16(cpustate, res);
 
1417
                m_r[dr] = EXTEND16_TO_24(res);
 
1418
        SET_NZ00_16(res);
1399
1419
}
1400
1420
 
1401
1421
 
1402
 
static void or_di(dsp32_state *cpustate, UINT32 op)
 
1422
void dsp32c_device::or_di(UINT32 op)
1403
1423
{
1404
1424
        int dr = (op >> 16) & 0x1f;
1405
 
        int drval = REG16(cpustate, dr);
 
1425
        int drval = REG16(dr);
1406
1426
        int res = drval | (UINT16)op;
1407
1427
        if (IS_WRITEABLE(dr))
1408
 
                cpustate->r[dr] = EXTEND16_TO_24(res);
1409
 
        SET_NZ00_16(cpustate, res);
 
1428
                m_r[dr] = EXTEND16_TO_24(res);
 
1429
        SET_NZ00_16(res);
1410
1430
}
1411
1431
 
1412
1432
 
1413
 
static void and_di(dsp32_state *cpustate, UINT32 op)
 
1433
void dsp32c_device::and_di(UINT32 op)
1414
1434
{
1415
1435
        int dr = (op >> 16) & 0x1f;
1416
 
        int drval = REG16(cpustate, dr);
 
1436
        int drval = REG16(dr);
1417
1437
        int res = drval & (UINT16)op;
1418
1438
        if (IS_WRITEABLE(dr))
1419
 
                cpustate->r[dr] = EXTEND16_TO_24(res);
1420
 
        SET_NZ00_16(cpustate, res);
 
1439
                m_r[dr] = EXTEND16_TO_24(res);
 
1440
        SET_NZ00_16(res);
1421
1441
}
1422
1442
 
1423
1443
 
1424
 
static void test_di(dsp32_state *cpustate, UINT32 op)
 
1444
void dsp32c_device::test_di(UINT32 op)
1425
1445
{
1426
 
        int drval = REG16(cpustate, (op >> 16) & 0x1f);
 
1446
        int drval = REG16((op >> 16) & 0x1f);
1427
1447
        int res = drval & (UINT16)op;
1428
 
        SET_NZ00_16(cpustate, res);
 
1448
        SET_NZ00_16(res);
1429
1449
}
1430
1450
 
1431
1451
 
1432
1452
 
1433
 
/***************************************************************************
1434
 
    CAU 24-BIT ARITHMETIC IMPLEMENTATION
1435
 
***************************************************************************/
 
1453
//**************************************************************************
 
1454
//  CAU 24-BIT ARITHMETIC IMPLEMENTATION
 
1455
//**************************************************************************
1436
1456
 
1437
 
static void adde_si(dsp32_state *cpustate, UINT32 op)
 
1457
void dsp32c_device::adde_si(UINT32 op)
1438
1458
{
1439
1459
        int dr = (op >> 21) & 0x1f;
1440
 
        int hrval = REG24(cpustate, (op >> 16) & 0x1f);
 
1460
        int hrval = REG24((op >> 16) & 0x1f);
1441
1461
        int res = hrval + EXTEND16_TO_24(op);
1442
1462
        if (IS_WRITEABLE(dr))
1443
 
                cpustate->r[dr] = TRUNCATE24(res);
1444
 
        SET_NZCV_24(cpustate, hrval, op << 8, res);
 
1463
                m_r[dr] = TRUNCATE24(res);
 
1464
        SET_NZCV_24(hrval, op << 8, res);
1445
1465
}
1446
1466
 
1447
1467
 
1448
 
static void adde_ss(dsp32_state *cpustate, UINT32 op)
 
1468
void dsp32c_device::adde_ss(UINT32 op)
1449
1469
{
1450
 
        if (CONDITION_IS_TRUE(cpustate))
 
1470
        if (CONDITION_IS_TRUE())
1451
1471
        {
1452
1472
                int dr = (op >> 16) & 0x1f;
1453
 
                int s1rval = REG24(cpustate, (op >> 5) & 0x1f);
1454
 
                int s2rval = (op & 0x800) ? REG24(cpustate, (op >> 0) & 0x1f) : REG24(cpustate, dr);
 
1473
                int s1rval = REG24((op >> 5) & 0x1f);
 
1474
                int s2rval = (op & 0x800) ? REG24((op >> 0) & 0x1f) : REG24(dr);
1455
1475
                int res = s2rval + s1rval;
1456
1476
                if (IS_WRITEABLE(dr))
1457
 
                        cpustate->r[dr] = TRUNCATE24(res);
1458
 
                SET_NZCV_24(cpustate, s1rval, s2rval, res);
 
1477
                        m_r[dr] = TRUNCATE24(res);
 
1478
                SET_NZCV_24(s1rval, s2rval, res);
1459
1479
        }
1460
1480
}
1461
1481
 
1462
1482
 
1463
 
static void mul2e_s(dsp32_state *cpustate, UINT32 op)
 
1483
void dsp32c_device::mul2e_s(UINT32 op)
1464
1484
{
1465
 
        if (CONDITION_IS_TRUE(cpustate))
 
1485
        if (CONDITION_IS_TRUE())
1466
1486
        {
1467
1487
                int dr = (op >> 16) & 0x1f;
1468
 
                int s1rval = REG24(cpustate, (op >> 5) & 0x1f);
 
1488
                int s1rval = REG24((op >> 5) & 0x1f);
1469
1489
                int res = s1rval * 2;
1470
1490
                if (IS_WRITEABLE(dr))
1471
 
                        cpustate->r[dr] = TRUNCATE24(res);
1472
 
                SET_NZCV_24(cpustate, s1rval, 0, res);
 
1491
                        m_r[dr] = TRUNCATE24(res);
 
1492
                SET_NZCV_24(s1rval, 0, res);
1473
1493
        }
1474
1494
}
1475
1495
 
1476
1496
 
1477
 
static void subre_ss(dsp32_state *cpustate, UINT32 op)
 
1497
void dsp32c_device::subre_ss(UINT32 op)
1478
1498
{
1479
 
        if (CONDITION_IS_TRUE(cpustate))
 
1499
        if (CONDITION_IS_TRUE())
1480
1500
        {
1481
1501
                int dr = (op >> 16) & 0x1f;
1482
 
                int s1rval = REG24(cpustate, (op >> 5) & 0x1f);
1483
 
                int s2rval = (op & 0x800) ? REG24(cpustate, (op >> 0) & 0x1f) : REG24(cpustate, dr);
 
1502
                int s1rval = REG24((op >> 5) & 0x1f);
 
1503
                int s2rval = (op & 0x800) ? REG24((op >> 0) & 0x1f) : REG24(dr);
1484
1504
                int res = s1rval - s2rval;
1485
1505
                if (IS_WRITEABLE(dr))
1486
 
                        cpustate->r[dr] = TRUNCATE24(res);
1487
 
                SET_NZCV_24(cpustate, s1rval, s2rval, res);
 
1506
                        m_r[dr] = TRUNCATE24(res);
 
1507
                SET_NZCV_24(s1rval, s2rval, res);
1488
1508
        }
1489
1509
}
1490
1510
 
1491
1511
 
1492
 
static void addre_ss(dsp32_state *cpustate, UINT32 op)
 
1512
void dsp32c_device::addre_ss(UINT32 op)
1493
1513
{
1494
 
        unimplemented(cpustate, op);
 
1514
        unimplemented(op);
1495
1515
}
1496
1516
 
1497
1517
 
1498
 
static void sube_ss(dsp32_state *cpustate, UINT32 op)
 
1518
void dsp32c_device::sube_ss(UINT32 op)
1499
1519
{
1500
 
        if (CONDITION_IS_TRUE(cpustate))
 
1520
        if (CONDITION_IS_TRUE())
1501
1521
        {
1502
1522
                int dr = (op >> 16) & 0x1f;
1503
 
                int s1rval = REG24(cpustate, (op >> 5) & 0x1f);
1504
 
                int s2rval = (op & 0x800) ? REG24(cpustate, (op >> 0) & 0x1f) : REG24(cpustate, dr);
 
1523
                int s1rval = REG24((op >> 5) & 0x1f);
 
1524
                int s2rval = (op & 0x800) ? REG24((op >> 0) & 0x1f) : REG24(dr);
1505
1525
                int res = s2rval - s1rval;
1506
1526
                if (IS_WRITEABLE(dr))
1507
 
                        cpustate->r[dr] = TRUNCATE24(res);
1508
 
                SET_NZCV_24(cpustate, s1rval, s2rval, res);
 
1527
                        m_r[dr] = TRUNCATE24(res);
 
1528
                SET_NZCV_24(s1rval, s2rval, res);
1509
1529
        }
1510
1530
}
1511
1531
 
1512
1532
 
1513
 
static void nege_s(dsp32_state *cpustate, UINT32 op)
 
1533
void dsp32c_device::nege_s(UINT32 op)
1514
1534
{
1515
 
        if (CONDITION_IS_TRUE(cpustate))
 
1535
        if (CONDITION_IS_TRUE())
1516
1536
        {
1517
1537
                int dr = (op >> 16) & 0x1f;
1518
 
                int s1rval = REG24(cpustate, (op >> 5) & 0x1f);
 
1538
                int s1rval = REG24((op >> 5) & 0x1f);
1519
1539
                int res = -s1rval;
1520
1540
                if (IS_WRITEABLE(dr))
1521
 
                        cpustate->r[dr] = TRUNCATE24(res);
1522
 
                SET_NZCV_24(cpustate, s1rval, 0, res);
 
1541
                        m_r[dr] = TRUNCATE24(res);
 
1542
                SET_NZCV_24(s1rval, 0, res);
1523
1543
        }
1524
1544
}
1525
1545
 
1526
1546
 
1527
 
static void andce_ss(dsp32_state *cpustate, UINT32 op)
 
1547
void dsp32c_device::andce_ss(UINT32 op)
1528
1548
{
1529
 
        if (CONDITION_IS_TRUE(cpustate))
 
1549
        if (CONDITION_IS_TRUE())
1530
1550
        {
1531
1551
                int dr = (op >> 16) & 0x1f;
1532
 
                int s1rval = REG24(cpustate, (op >> 5) & 0x1f);
1533
 
                int s2rval = (op & 0x800) ? REG24(cpustate, (op >> 0) & 0x1f) : REG24(cpustate, dr);
 
1552
                int s1rval = REG24((op >> 5) & 0x1f);
 
1553
                int s2rval = (op & 0x800) ? REG24((op >> 0) & 0x1f) : REG24(dr);
1534
1554
                int res = s2rval & ~s1rval;
1535
1555
                if (IS_WRITEABLE(dr))
1536
 
                        cpustate->r[dr] = res;
1537
 
                SET_NZ00_24(cpustate, res);
 
1556
                        m_r[dr] = res;
 
1557
                SET_NZ00_24(res);
1538
1558
        }
1539
1559
}
1540
1560
 
1541
1561
 
1542
 
static void cmpe_ss(dsp32_state *cpustate, UINT32 op)
 
1562
void dsp32c_device::cmpe_ss(UINT32 op)
1543
1563
{
1544
 
        if (CONDITION_IS_TRUE(cpustate))
 
1564
        if (CONDITION_IS_TRUE())
1545
1565
        {
1546
 
                int drval = REG24(cpustate, (op >> 16) & 0x1f);
1547
 
                int s1rval = REG24(cpustate, (op >> 5) & 0x1f);
 
1566
                int drval = REG24((op >> 16) & 0x1f);
 
1567
                int s1rval = REG24((op >> 5) & 0x1f);
1548
1568
                int res = drval - s1rval;
1549
 
                SET_NZCV_24(cpustate, drval, s1rval, res);
 
1569
                SET_NZCV_24(drval, s1rval, res);
1550
1570
        }
1551
1571
}
1552
1572
 
1553
1573
 
1554
 
static void xore_ss(dsp32_state *cpustate, UINT32 op)
 
1574
void dsp32c_device::xore_ss(UINT32 op)
1555
1575
{
1556
 
        if (CONDITION_IS_TRUE(cpustate))
 
1576
        if (CONDITION_IS_TRUE())
1557
1577
        {
1558
1578
                int dr = (op >> 16) & 0x1f;
1559
 
                int s1rval = REG24(cpustate, (op >> 5) & 0x1f);
1560
 
                int s2rval = (op & 0x800) ? REG24(cpustate, (op >> 0) & 0x1f) : REG24(cpustate, dr);
 
1579
                int s1rval = REG24((op >> 5) & 0x1f);
 
1580
                int s2rval = (op & 0x800) ? REG24((op >> 0) & 0x1f) : REG24(dr);
1561
1581
                int res = s2rval ^ s1rval;
1562
1582
                if (IS_WRITEABLE(dr))
1563
 
                        cpustate->r[dr] = res;
1564
 
                SET_NZ00_24(cpustate, res);
 
1583
                        m_r[dr] = res;
 
1584
                SET_NZ00_24(res);
1565
1585
        }
1566
1586
}
1567
1587
 
1568
1588
 
1569
 
static void rcre_s(dsp32_state *cpustate, UINT32 op)
 
1589
void dsp32c_device::rcre_s(UINT32 op)
1570
1590
{
1571
 
        if (CONDITION_IS_TRUE(cpustate))
 
1591
        if (CONDITION_IS_TRUE())
1572
1592
        {
1573
1593
                int dr = (op >> 16) & 0x1f;
1574
 
                int s1rval = REG24(cpustate, (op >> 5) & 0x1f);
1575
 
                int res = ((cpustate->nzcflags >> 1) & 0x800000) | (s1rval >> 1);
 
1594
                int s1rval = REG24((op >> 5) & 0x1f);
 
1595
                int res = ((m_nzcflags >> 1) & 0x800000) | (s1rval >> 1);
1576
1596
                if (IS_WRITEABLE(dr))
1577
 
                        cpustate->r[dr] = TRUNCATE24(res);
1578
 
                cpustate->nzcflags = res | ((s1rval & 1) << 24);
1579
 
                cpustate->vflags = 0;
 
1597
                        m_r[dr] = TRUNCATE24(res);
 
1598
                m_nzcflags = res | ((s1rval & 1) << 24);
 
1599
                m_vflags = 0;
1580
1600
        }
1581
1601
}
1582
1602
 
1583
1603
 
1584
 
static void ore_ss(dsp32_state *cpustate, UINT32 op)
 
1604
void dsp32c_device::ore_ss(UINT32 op)
1585
1605
{
1586
 
        if (CONDITION_IS_TRUE(cpustate))
 
1606
        if (CONDITION_IS_TRUE())
1587
1607
        {
1588
1608
                int dr = (op >> 16) & 0x1f;
1589
 
                int s1rval = REG24(cpustate, (op >> 5) & 0x1f);
1590
 
                int s2rval = (op & 0x800) ? REG24(cpustate, (op >> 0) & 0x1f) : REG24(cpustate, dr);
 
1609
                int s1rval = REG24((op >> 5) & 0x1f);
 
1610
                int s2rval = (op & 0x800) ? REG24((op >> 0) & 0x1f) : REG24(dr);
1591
1611
                int res = s2rval | s1rval;
1592
1612
                if (IS_WRITEABLE(dr))
1593
 
                        cpustate->r[dr] = res;
1594
 
                SET_NZ00_24(cpustate, res);
 
1613
                        m_r[dr] = res;
 
1614
                SET_NZ00_24(res);
1595
1615
        }
1596
1616
}
1597
1617
 
1598
1618
 
1599
 
static void rcle_s(dsp32_state *cpustate, UINT32 op)
 
1619
void dsp32c_device::rcle_s(UINT32 op)
1600
1620
{
1601
 
        if (CONDITION_IS_TRUE(cpustate))
 
1621
        if (CONDITION_IS_TRUE())
1602
1622
        {
1603
1623
                int dr = (op >> 16) & 0x1f;
1604
 
                int s1rval = REG24(cpustate, (op >> 5) & 0x1f);
1605
 
                int res = ((cpustate->nzcflags >> 24) & 0x000001) | (s1rval << 1);
 
1624
                int s1rval = REG24((op >> 5) & 0x1f);
 
1625
                int res = ((m_nzcflags >> 24) & 0x000001) | (s1rval << 1);
1606
1626
                if (IS_WRITEABLE(dr))
1607
 
                        cpustate->r[dr] = TRUNCATE24(res);
1608
 
                cpustate->nzcflags = res | ((s1rval & 0x800000) << 1);
1609
 
                cpustate->vflags = 0;
 
1627
                        m_r[dr] = TRUNCATE24(res);
 
1628
                m_nzcflags = res | ((s1rval & 0x800000) << 1);
 
1629
                m_vflags = 0;
1610
1630
        }
1611
1631
}
1612
1632
 
1613
1633
 
1614
 
static void shre_s(dsp32_state *cpustate, UINT32 op)
 
1634
void dsp32c_device::shre_s(UINT32 op)
1615
1635
{
1616
 
        if (CONDITION_IS_TRUE(cpustate))
 
1636
        if (CONDITION_IS_TRUE())
1617
1637
        {
1618
1638
                int dr = (op >> 16) & 0x1f;
1619
 
                int s1rval = REG24(cpustate, (op >> 5) & 0x1f);
 
1639
                int s1rval = REG24((op >> 5) & 0x1f);
1620
1640
                int res = s1rval >> 1;
1621
1641
                if (IS_WRITEABLE(dr))
1622
 
                        cpustate->r[dr] = res;
1623
 
                cpustate->nzcflags = res | ((s1rval & 1) << 24);
1624
 
                cpustate->vflags = 0;
 
1642
                        m_r[dr] = res;
 
1643
                m_nzcflags = res | ((s1rval & 1) << 24);
 
1644
                m_vflags = 0;
1625
1645
        }
1626
1646
}
1627
1647
 
1628
1648
 
1629
 
static void div2e_s(dsp32_state *cpustate, UINT32 op)
 
1649
void dsp32c_device::div2e_s(UINT32 op)
1630
1650
{
1631
 
        if (CONDITION_IS_TRUE(cpustate))
 
1651
        if (CONDITION_IS_TRUE())
1632
1652
        {
1633
1653
                int dr = (op >> 16) & 0x1f;
1634
 
                int s1rval = REG24(cpustate, (op >> 5) & 0x1f);
 
1654
                int s1rval = REG24((op >> 5) & 0x1f);
1635
1655
                int res = (s1rval & 0x800000) | (s1rval >> 1);
1636
1656
                if (IS_WRITEABLE(dr))
1637
 
                        cpustate->r[dr] = TRUNCATE24(res);
1638
 
                cpustate->nzcflags = res | ((s1rval & 1) << 24);
1639
 
                cpustate->vflags = 0;
 
1657
                        m_r[dr] = TRUNCATE24(res);
 
1658
                m_nzcflags = res | ((s1rval & 1) << 24);
 
1659
                m_vflags = 0;
1640
1660
        }
1641
1661
}
1642
1662
 
1643
1663
 
1644
 
static void ande_ss(dsp32_state *cpustate, UINT32 op)
 
1664
void dsp32c_device::ande_ss(UINT32 op)
1645
1665
{
1646
 
        if (CONDITION_IS_TRUE(cpustate))
 
1666
        if (CONDITION_IS_TRUE())
1647
1667
        {
1648
1668
                int dr = (op >> 16) & 0x1f;
1649
 
                int s1rval = REG24(cpustate, (op >> 5) & 0x1f);
1650
 
                int s2rval = (op & 0x800) ? REG24(cpustate, (op >> 0) & 0x1f) : REG24(cpustate, dr);
 
1669
                int s1rval = REG24((op >> 5) & 0x1f);
 
1670
                int s2rval = (op & 0x800) ? REG24((op >> 0) & 0x1f) : REG24(dr);
1651
1671
                int res = s2rval & s1rval;
1652
1672
                if (IS_WRITEABLE(dr))
1653
 
                        cpustate->r[dr] = res;
1654
 
                SET_NZ00_24(cpustate, res);
 
1673
                        m_r[dr] = res;
 
1674
                SET_NZ00_24(res);
1655
1675
        }
1656
1676
}
1657
1677
 
1658
1678
 
1659
 
static void teste_ss(dsp32_state *cpustate, UINT32 op)
 
1679
void dsp32c_device::teste_ss(UINT32 op)
1660
1680
{
1661
 
        if (CONDITION_IS_TRUE(cpustate))
 
1681
        if (CONDITION_IS_TRUE())
1662
1682
        {
1663
 
                int drval = REG24(cpustate, (op >> 16) & 0x1f);
1664
 
                int s1rval = REG24(cpustate, (op >> 5) & 0x1f);
 
1683
                int drval = REG24((op >> 16) & 0x1f);
 
1684
                int s1rval = REG24((op >> 5) & 0x1f);
1665
1685
                int res = drval & s1rval;
1666
 
                SET_NZ00_24(cpustate, res);
 
1686
                SET_NZ00_24(res);
1667
1687
        }
1668
1688
}
1669
1689
 
1670
1690
 
1671
 
static void adde_di(dsp32_state *cpustate, UINT32 op)
 
1691
void dsp32c_device::adde_di(UINT32 op)
1672
1692
{
1673
1693
        int dr = (op >> 16) & 0x1f;
1674
 
        int drval = REG24(cpustate, dr);
 
1694
        int drval = REG24(dr);
1675
1695
        int res = drval + EXTEND16_TO_24(op);
1676
1696
        if (IS_WRITEABLE(dr))
1677
 
                cpustate->r[dr] = TRUNCATE24(res);
1678
 
        SET_NZCV_24(cpustate, drval, op << 8, res);
 
1697
                m_r[dr] = TRUNCATE24(res);
 
1698
        SET_NZCV_24(drval, op << 8, res);
1679
1699
}
1680
1700
 
1681
1701
 
1682
 
static void subre_di(dsp32_state *cpustate, UINT32 op)
 
1702
void dsp32c_device::subre_di(UINT32 op)
1683
1703
{
1684
1704
        int dr = (op >> 16) & 0x1f;
1685
 
        int drval = REG24(cpustate, dr);
 
1705
        int drval = REG24(dr);
1686
1706
        int res = EXTEND16_TO_24(op) - drval;
1687
1707
        if (IS_WRITEABLE(dr))
1688
 
                cpustate->r[dr] = TRUNCATE24(res);
1689
 
        SET_NZCV_24(cpustate, drval, op << 8, res);
 
1708
                m_r[dr] = TRUNCATE24(res);
 
1709
        SET_NZCV_24(drval, op << 8, res);
1690
1710
}
1691
1711
 
1692
1712
 
1693
 
static void addre_di(dsp32_state *cpustate, UINT32 op)
 
1713
void dsp32c_device::addre_di(UINT32 op)
1694
1714
{
1695
 
        unimplemented(cpustate, op);
 
1715
        unimplemented(op);
1696
1716
}
1697
1717
 
1698
1718
 
1699
 
static void sube_di(dsp32_state *cpustate, UINT32 op)
 
1719
void dsp32c_device::sube_di(UINT32 op)
1700
1720
{
1701
1721
        int dr = (op >> 16) & 0x1f;
1702
 
        int drval = REG24(cpustate, dr);
 
1722
        int drval = REG24(dr);
1703
1723
        int res = drval - EXTEND16_TO_24(op);
1704
1724
        if (IS_WRITEABLE(dr))
1705
 
                cpustate->r[dr] = TRUNCATE24(res);
1706
 
        SET_NZCV_24(cpustate, drval, op << 8, res);
 
1725
                m_r[dr] = TRUNCATE24(res);
 
1726
        SET_NZCV_24(drval, op << 8, res);
1707
1727
}
1708
1728
 
1709
1729
 
1710
 
static void andce_di(dsp32_state *cpustate, UINT32 op)
 
1730
void dsp32c_device::andce_di(UINT32 op)
1711
1731
{
1712
1732
        int dr = (op >> 16) & 0x1f;
1713
 
        int drval = REG24(cpustate, dr);
 
1733
        int drval = REG24(dr);
1714
1734
        int res = drval & ~EXTEND16_TO_24(op);
1715
1735
        if (IS_WRITEABLE(dr))
1716
 
                cpustate->r[dr] = res;
1717
 
        SET_NZ00_24(cpustate, res);
 
1736
                m_r[dr] = res;
 
1737
        SET_NZ00_24(res);
1718
1738
}
1719
1739
 
1720
1740
 
1721
 
static void cmpe_di(dsp32_state *cpustate, UINT32 op)
 
1741
void dsp32c_device::cmpe_di(UINT32 op)
1722
1742
{
1723
 
        int drval = REG24(cpustate, (op >> 16) & 0x1f);
 
1743
        int drval = REG24((op >> 16) & 0x1f);
1724
1744
        int res = drval - EXTEND16_TO_24(op);
1725
 
        SET_NZCV_24(cpustate, drval, op << 8, res);
 
1745
        SET_NZCV_24(drval, op << 8, res);
1726
1746
}
1727
1747
 
1728
1748
 
1729
 
static void xore_di(dsp32_state *cpustate, UINT32 op)
 
1749
void dsp32c_device::xore_di(UINT32 op)
1730
1750
{
1731
1751
        int dr = (op >> 16) & 0x1f;
1732
 
        int drval = REG24(cpustate, dr);
 
1752
        int drval = REG24(dr);
1733
1753
        int res = drval ^ EXTEND16_TO_24(op);
1734
1754
        if (IS_WRITEABLE(dr))
1735
 
                cpustate->r[dr] = res;
1736
 
        SET_NZ00_24(cpustate, res);
 
1755
                m_r[dr] = res;
 
1756
        SET_NZ00_24(res);
1737
1757
}
1738
1758
 
1739
1759
 
1740
 
static void ore_di(dsp32_state *cpustate, UINT32 op)
 
1760
void dsp32c_device::ore_di(UINT32 op)
1741
1761
{
1742
1762
        int dr = (op >> 16) & 0x1f;
1743
 
        int drval = REG24(cpustate, dr);
 
1763
        int drval = REG24(dr);
1744
1764
        int res = drval | EXTEND16_TO_24(op);
1745
1765
        if (IS_WRITEABLE(dr))
1746
 
                cpustate->r[dr] = res;
1747
 
        SET_NZ00_24(cpustate, res);
1748
 
}
1749
 
 
1750
 
 
1751
 
static void ande_di(dsp32_state *cpustate, UINT32 op)
1752
 
{
1753
 
        int dr = (op >> 16) & 0x1f;
1754
 
        int drval = REG24(cpustate, dr);
1755
 
        int res = drval & EXTEND16_TO_24(op);
1756
 
        if (IS_WRITEABLE(dr))
1757
 
                cpustate->r[dr] = res;
1758
 
        SET_NZ00_24(cpustate, res);
1759
 
}
1760
 
 
1761
 
 
1762
 
static void teste_di(dsp32_state *cpustate, UINT32 op)
1763
 
{
1764
 
        int drval = REG24(cpustate, (op >> 16) & 0x1f);
1765
 
        int res = drval & EXTEND16_TO_24(op);
1766
 
        SET_NZ00_24(cpustate, res);
1767
 
}
1768
 
 
1769
 
 
1770
 
 
1771
 
/***************************************************************************
1772
 
    CAU LOAD/STORE IMPLEMENTATION
1773
 
***************************************************************************/
1774
 
 
1775
 
static void load_hi(dsp32_state *cpustate, UINT32 op)
1776
 
{
1777
 
        int dr = (op >> 16) & 0x1f;
1778
 
        UINT32 res = RBYTE(cpustate, EXTEND16_TO_24(op));
1779
 
        if (IS_WRITEABLE(dr))
1780
 
                cpustate->r[dr] = EXTEND16_TO_24(res);
1781
 
        cpustate->nzcflags = res << 8;
1782
 
        cpustate->vflags = 0;
1783
 
}
1784
 
 
1785
 
 
1786
 
static void load_li(dsp32_state *cpustate, UINT32 op)
1787
 
{
1788
 
        int dr = (op >> 16) & 0x1f;
1789
 
        UINT32 res = RBYTE(cpustate, EXTEND16_TO_24(op));
1790
 
        if (IS_WRITEABLE(dr))
1791
 
                cpustate->r[dr] = res;
1792
 
        cpustate->nzcflags = res << 8;
1793
 
        cpustate->vflags = 0;
1794
 
}
1795
 
 
1796
 
 
1797
 
static void load_i(dsp32_state *cpustate, UINT32 op)
1798
 
{
1799
 
        UINT32 res = RWORD(cpustate, EXTEND16_TO_24(op));
1800
 
        int dr = (op >> 16) & 0x1f;
1801
 
        if (IS_WRITEABLE(dr))
1802
 
                cpustate->r[dr] = EXTEND16_TO_24(res);
1803
 
        cpustate->nzcflags = res << 8;
1804
 
        cpustate->vflags = 0;
1805
 
}
1806
 
 
1807
 
 
1808
 
static void load_ei(dsp32_state *cpustate, UINT32 op)
1809
 
{
1810
 
        UINT32 res = TRUNCATE24(RLONG(cpustate, EXTEND16_TO_24(op)));
1811
 
        int dr = (op >> 16) & 0x1f;
1812
 
        if (IS_WRITEABLE(dr))
1813
 
                cpustate->r[dr] = res;
1814
 
        cpustate->nzcflags = res;
1815
 
        cpustate->vflags = 0;
1816
 
}
1817
 
 
1818
 
 
1819
 
static void store_hi(dsp32_state *cpustate, UINT32 op)
1820
 
{
1821
 
        WBYTE(cpustate, EXTEND16_TO_24(op), cpustate->r[(op >> 16) & 0x1f] >> 8);
1822
 
}
1823
 
 
1824
 
 
1825
 
static void store_li(dsp32_state *cpustate, UINT32 op)
1826
 
{
1827
 
        WBYTE(cpustate, EXTEND16_TO_24(op), cpustate->r[(op >> 16) & 0x1f]);
1828
 
}
1829
 
 
1830
 
 
1831
 
static void store_i(dsp32_state *cpustate, UINT32 op)
1832
 
{
1833
 
        WWORD(cpustate, EXTEND16_TO_24(op), REG16(cpustate, (op >> 16) & 0x1f));
1834
 
}
1835
 
 
1836
 
 
1837
 
static void store_ei(dsp32_state *cpustate, UINT32 op)
1838
 
{
1839
 
        WLONG(cpustate, EXTEND16_TO_24(op), (INT32)(REG24(cpustate, (op >> 16) & 0x1f) << 8) >> 8);
1840
 
}
1841
 
 
1842
 
 
1843
 
static void load_hr(dsp32_state *cpustate, UINT32 op)
1844
 
{
1845
 
        if (!(op & 0x400))
1846
 
        {
1847
 
                int dr = (op >> 16) & 0x1f;
1848
 
                UINT32 res = cau_read_pi_1byte(cpustate, op) << 8;
1849
 
                if (IS_WRITEABLE(dr))
1850
 
                        cpustate->r[dr] = EXTEND16_TO_24(res);
1851
 
                cpustate->nzcflags = res << 8;
1852
 
                cpustate->vflags = 0;
1853
 
        }
1854
 
        else
1855
 
                unimplemented(cpustate, op);
1856
 
}
1857
 
 
1858
 
 
1859
 
static void load_lr(dsp32_state *cpustate, UINT32 op)
1860
 
{
1861
 
        if (!(op & 0x400))
1862
 
        {
1863
 
                int dr = (op >> 16) & 0x1f;
1864
 
                UINT32 res = cau_read_pi_1byte(cpustate, op);
1865
 
                if (IS_WRITEABLE(dr))
1866
 
                        cpustate->r[dr] = res;
1867
 
                cpustate->nzcflags = res << 8;
1868
 
                cpustate->vflags = 0;
1869
 
        }
1870
 
        else
1871
 
                unimplemented(cpustate, op);
1872
 
}
1873
 
 
1874
 
 
1875
 
static void load_r(dsp32_state *cpustate, UINT32 op)
1876
 
{
1877
 
        if (!(op & 0x400))
1878
 
        {
1879
 
                UINT32 res = cau_read_pi_2byte(cpustate, op);
1880
 
                int dr = (op >> 16) & 0x1f;
1881
 
                if (IS_WRITEABLE(dr))
1882
 
                        cpustate->r[dr] = EXTEND16_TO_24(res);
1883
 
                cpustate->nzcflags = res << 8;
1884
 
                cpustate->vflags = 0;
1885
 
        }
1886
 
        else
1887
 
                unimplemented(cpustate, op);
1888
 
}
1889
 
 
1890
 
 
1891
 
static void load_er(dsp32_state *cpustate, UINT32 op)
1892
 
{
1893
 
        if (!(op & 0x400))
1894
 
        {
1895
 
                UINT32 res = TRUNCATE24(cau_read_pi_4byte(cpustate, op));
1896
 
                int dr = (op >> 16) & 0x1f;
1897
 
                if (IS_WRITEABLE(dr))
1898
 
                        cpustate->r[dr] = res;
1899
 
                cpustate->nzcflags = res;
1900
 
                cpustate->vflags = 0;
1901
 
        }
1902
 
        else
1903
 
                unimplemented(cpustate, op);
1904
 
}
1905
 
 
1906
 
 
1907
 
static void store_hr(dsp32_state *cpustate, UINT32 op)
1908
 
{
1909
 
        if (!(op & 0x400))
1910
 
                cau_write_pi_1byte(cpustate, op, cpustate->r[(op >> 16) & 0x1f] >> 8);
1911
 
        else
1912
 
                unimplemented(cpustate, op);
1913
 
}
1914
 
 
1915
 
 
1916
 
static void store_lr(dsp32_state *cpustate, UINT32 op)
1917
 
{
1918
 
        if (!(op & 0x400))
1919
 
                cau_write_pi_1byte(cpustate, op, cpustate->r[(op >> 16) & 0x1f]);
1920
 
        else
1921
 
                unimplemented(cpustate, op);
1922
 
}
1923
 
 
1924
 
 
1925
 
static void store_r(dsp32_state *cpustate, UINT32 op)
1926
 
{
1927
 
        if (!(op & 0x400))
1928
 
                cau_write_pi_2byte(cpustate, op, REG16(cpustate, (op >> 16) & 0x1f));
1929
 
        else
1930
 
                unimplemented(cpustate, op);
1931
 
}
1932
 
 
1933
 
 
1934
 
static void store_er(dsp32_state *cpustate, UINT32 op)
1935
 
{
1936
 
        if (!(op & 0x400))
1937
 
                cau_write_pi_4byte(cpustate, op, REG24(cpustate, (op >> 16) & 0x1f));
1938
 
        else
1939
 
                unimplemented(cpustate, op);
1940
 
}
1941
 
 
1942
 
 
1943
 
static void load24(dsp32_state *cpustate, UINT32 op)
 
1766
                m_r[dr] = res;
 
1767
        SET_NZ00_24(res);
 
1768
}
 
1769
 
 
1770
 
 
1771
void dsp32c_device::ande_di(UINT32 op)
 
1772
{
 
1773
        int dr = (op >> 16) & 0x1f;
 
1774
        int drval = REG24(dr);
 
1775
        int res = drval & EXTEND16_TO_24(op);
 
1776
        if (IS_WRITEABLE(dr))
 
1777
                m_r[dr] = res;
 
1778
        SET_NZ00_24(res);
 
1779
}
 
1780
 
 
1781
 
 
1782
void dsp32c_device::teste_di(UINT32 op)
 
1783
{
 
1784
        int drval = REG24((op >> 16) & 0x1f);
 
1785
        int res = drval & EXTEND16_TO_24(op);
 
1786
        SET_NZ00_24(res);
 
1787
}
 
1788
 
 
1789
 
 
1790
 
 
1791
//**************************************************************************
 
1792
//  CAU LOAD/STORE IMPLEMENTATION
 
1793
//**************************************************************************
 
1794
 
 
1795
void dsp32c_device::load_hi(UINT32 op)
 
1796
{
 
1797
        int dr = (op >> 16) & 0x1f;
 
1798
        UINT32 res = RBYTE(EXTEND16_TO_24(op));
 
1799
        if (IS_WRITEABLE(dr))
 
1800
                m_r[dr] = EXTEND16_TO_24(res);
 
1801
        m_nzcflags = res << 8;
 
1802
        m_vflags = 0;
 
1803
}
 
1804
 
 
1805
 
 
1806
void dsp32c_device::load_li(UINT32 op)
 
1807
{
 
1808
        int dr = (op >> 16) & 0x1f;
 
1809
        UINT32 res = RBYTE(EXTEND16_TO_24(op));
 
1810
        if (IS_WRITEABLE(dr))
 
1811
                m_r[dr] = res;
 
1812
        m_nzcflags = res << 8;
 
1813
        m_vflags = 0;
 
1814
}
 
1815
 
 
1816
 
 
1817
void dsp32c_device::load_i(UINT32 op)
 
1818
{
 
1819
        UINT32 res = RWORD(EXTEND16_TO_24(op));
 
1820
        int dr = (op >> 16) & 0x1f;
 
1821
        if (IS_WRITEABLE(dr))
 
1822
                m_r[dr] = EXTEND16_TO_24(res);
 
1823
        m_nzcflags = res << 8;
 
1824
        m_vflags = 0;
 
1825
}
 
1826
 
 
1827
 
 
1828
void dsp32c_device::load_ei(UINT32 op)
 
1829
{
 
1830
        UINT32 res = TRUNCATE24(RLONG(EXTEND16_TO_24(op)));
 
1831
        int dr = (op >> 16) & 0x1f;
 
1832
        if (IS_WRITEABLE(dr))
 
1833
                m_r[dr] = res;
 
1834
        m_nzcflags = res;
 
1835
        m_vflags = 0;
 
1836
}
 
1837
 
 
1838
 
 
1839
void dsp32c_device::store_hi(UINT32 op)
 
1840
{
 
1841
        WBYTE(EXTEND16_TO_24(op), m_r[(op >> 16) & 0x1f] >> 8);
 
1842
}
 
1843
 
 
1844
 
 
1845
void dsp32c_device::store_li(UINT32 op)
 
1846
{
 
1847
        WBYTE(EXTEND16_TO_24(op), m_r[(op >> 16) & 0x1f]);
 
1848
}
 
1849
 
 
1850
 
 
1851
void dsp32c_device::store_i(UINT32 op)
 
1852
{
 
1853
        WWORD(EXTEND16_TO_24(op), REG16((op >> 16) & 0x1f));
 
1854
}
 
1855
 
 
1856
 
 
1857
void dsp32c_device::store_ei(UINT32 op)
 
1858
{
 
1859
        WLONG(EXTEND16_TO_24(op), (INT32)(REG24((op >> 16) & 0x1f) << 8) >> 8);
 
1860
}
 
1861
 
 
1862
 
 
1863
void dsp32c_device::load_hr(UINT32 op)
 
1864
{
 
1865
        if (!(op & 0x400))
 
1866
        {
 
1867
                int dr = (op >> 16) & 0x1f;
 
1868
                UINT32 res = cau_read_pi_1byte(op) << 8;
 
1869
                if (IS_WRITEABLE(dr))
 
1870
                        m_r[dr] = EXTEND16_TO_24(res);
 
1871
                m_nzcflags = res << 8;
 
1872
                m_vflags = 0;
 
1873
        }
 
1874
        else
 
1875
                unimplemented(op);
 
1876
}
 
1877
 
 
1878
 
 
1879
void dsp32c_device::load_lr(UINT32 op)
 
1880
{
 
1881
        if (!(op & 0x400))
 
1882
        {
 
1883
                int dr = (op >> 16) & 0x1f;
 
1884
                UINT32 res = cau_read_pi_1byte(op);
 
1885
                if (IS_WRITEABLE(dr))
 
1886
                        m_r[dr] = res;
 
1887
                m_nzcflags = res << 8;
 
1888
                m_vflags = 0;
 
1889
        }
 
1890
        else
 
1891
                unimplemented(op);
 
1892
}
 
1893
 
 
1894
 
 
1895
void dsp32c_device::load_r(UINT32 op)
 
1896
{
 
1897
        if (!(op & 0x400))
 
1898
        {
 
1899
                UINT32 res = cau_read_pi_2byte(op);
 
1900
                int dr = (op >> 16) & 0x1f;
 
1901
                if (IS_WRITEABLE(dr))
 
1902
                        m_r[dr] = EXTEND16_TO_24(res);
 
1903
                m_nzcflags = res << 8;
 
1904
                m_vflags = 0;
 
1905
        }
 
1906
        else
 
1907
                unimplemented(op);
 
1908
}
 
1909
 
 
1910
 
 
1911
void dsp32c_device::load_er(UINT32 op)
 
1912
{
 
1913
        if (!(op & 0x400))
 
1914
        {
 
1915
                UINT32 res = TRUNCATE24(cau_read_pi_4byte(op));
 
1916
                int dr = (op >> 16) & 0x1f;
 
1917
                if (IS_WRITEABLE(dr))
 
1918
                        m_r[dr] = res;
 
1919
                m_nzcflags = res;
 
1920
                m_vflags = 0;
 
1921
        }
 
1922
        else
 
1923
                unimplemented(op);
 
1924
}
 
1925
 
 
1926
 
 
1927
void dsp32c_device::store_hr(UINT32 op)
 
1928
{
 
1929
        if (!(op & 0x400))
 
1930
                cau_write_pi_1byte(op, m_r[(op >> 16) & 0x1f] >> 8);
 
1931
        else
 
1932
                unimplemented(op);
 
1933
}
 
1934
 
 
1935
 
 
1936
void dsp32c_device::store_lr(UINT32 op)
 
1937
{
 
1938
        if (!(op & 0x400))
 
1939
                cau_write_pi_1byte(op, m_r[(op >> 16) & 0x1f]);
 
1940
        else
 
1941
                unimplemented(op);
 
1942
}
 
1943
 
 
1944
 
 
1945
void dsp32c_device::store_r(UINT32 op)
 
1946
{
 
1947
        if (!(op & 0x400))
 
1948
                cau_write_pi_2byte(op, REG16((op >> 16) & 0x1f));
 
1949
        else
 
1950
                unimplemented(op);
 
1951
}
 
1952
 
 
1953
 
 
1954
void dsp32c_device::store_er(UINT32 op)
 
1955
{
 
1956
        if (!(op & 0x400))
 
1957
                cau_write_pi_4byte(op, REG24((op >> 16) & 0x1f));
 
1958
        else
 
1959
                unimplemented(op);
 
1960
}
 
1961
 
 
1962
 
 
1963
void dsp32c_device::load24(UINT32 op)
1944
1964
{
1945
1965
        int dr = (op >> 16) & 0x1f;
1946
1966
        UINT32 res = (op & 0xffff) + ((op >> 5) & 0xff0000);
1947
1967
        if (IS_WRITEABLE(dr))
1948
 
                cpustate->r[dr] = res;
1949
 
}
1950
 
 
1951
 
 
1952
 
 
1953
 
/***************************************************************************
1954
 
    DAU FORM 1 IMPLEMENTATION
1955
 
***************************************************************************/
1956
 
 
1957
 
static void d1_aMpp(dsp32_state *cpustate, UINT32 op)
1958
 
{
1959
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
1960
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 0, xval);
1961
 
        double res = yval + DEFERRED_MULTIPLIER(cpustate, (op >> 26) & 7) * xval;
1962
 
        int zpi = (op >> 0) & 0x7f;
1963
 
        if (zpi != 7)
1964
 
                dau_write_pi_double(cpustate, zpi, res);
1965
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
1966
 
}
1967
 
 
1968
 
 
1969
 
static void d1_aMpm(dsp32_state *cpustate, UINT32 op)
1970
 
{
1971
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
1972
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 0, xval);
1973
 
        double res = yval - DEFERRED_MULTIPLIER(cpustate, (op >> 26) & 7) * xval;
1974
 
        int zpi = (op >> 0) & 0x7f;
1975
 
        if (zpi != 7)
1976
 
                dau_write_pi_double(cpustate, zpi, res);
1977
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
1978
 
}
1979
 
 
1980
 
 
1981
 
static void d1_aMmp(dsp32_state *cpustate, UINT32 op)
1982
 
{
1983
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
1984
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 0, xval);
1985
 
        double res = -yval + DEFERRED_MULTIPLIER(cpustate, (op >> 26) & 7) * xval;
1986
 
        int zpi = (op >> 0) & 0x7f;
1987
 
        if (zpi != 7)
1988
 
                dau_write_pi_double(cpustate, zpi, res);
1989
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
1990
 
}
1991
 
 
1992
 
 
1993
 
static void d1_aMmm(dsp32_state *cpustate, UINT32 op)
1994
 
{
1995
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
1996
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 0, xval);
1997
 
        double res = -yval - DEFERRED_MULTIPLIER(cpustate, (op >> 26) & 7) * xval;
1998
 
        int zpi = (op >> 0) & 0x7f;
1999
 
        if (zpi != 7)
2000
 
                dau_write_pi_double(cpustate, zpi, res);
2001
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
2002
 
}
2003
 
 
2004
 
 
2005
 
static void d1_0px(dsp32_state *cpustate, UINT32 op)
2006
 
{
2007
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
2008
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 0, xval);
 
1968
                m_r[dr] = res;
 
1969
}
 
1970
 
 
1971
 
 
1972
 
 
1973
//**************************************************************************
 
1974
//  DAU FORM 1 IMPLEMENTATION
 
1975
//**************************************************************************
 
1976
 
 
1977
void dsp32c_device::d1_aMpp(UINT32 op)
 
1978
{
 
1979
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
1980
        double yval = dau_read_pi_double_2nd(op >> 7, 0, xval);
 
1981
        double res = yval + DEFERRED_MULTIPLIER((op >> 26) & 7) * xval;
 
1982
        int zpi = (op >> 0) & 0x7f;
 
1983
        if (zpi != 7)
 
1984
                dau_write_pi_double(zpi, res);
 
1985
        dau_set_val_flags((op >> 21) & 3, res);
 
1986
}
 
1987
 
 
1988
 
 
1989
void dsp32c_device::d1_aMpm(UINT32 op)
 
1990
{
 
1991
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
1992
        double yval = dau_read_pi_double_2nd(op >> 7, 0, xval);
 
1993
        double res = yval - DEFERRED_MULTIPLIER((op >> 26) & 7) * xval;
 
1994
        int zpi = (op >> 0) & 0x7f;
 
1995
        if (zpi != 7)
 
1996
                dau_write_pi_double(zpi, res);
 
1997
        dau_set_val_flags((op >> 21) & 3, res);
 
1998
}
 
1999
 
 
2000
 
 
2001
void dsp32c_device::d1_aMmp(UINT32 op)
 
2002
{
 
2003
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
2004
        double yval = dau_read_pi_double_2nd(op >> 7, 0, xval);
 
2005
        double res = -yval + DEFERRED_MULTIPLIER((op >> 26) & 7) * xval;
 
2006
        int zpi = (op >> 0) & 0x7f;
 
2007
        if (zpi != 7)
 
2008
                dau_write_pi_double(zpi, res);
 
2009
        dau_set_val_flags((op >> 21) & 3, res);
 
2010
}
 
2011
 
 
2012
 
 
2013
void dsp32c_device::d1_aMmm(UINT32 op)
 
2014
{
 
2015
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
2016
        double yval = dau_read_pi_double_2nd(op >> 7, 0, xval);
 
2017
        double res = -yval - DEFERRED_MULTIPLIER((op >> 26) & 7) * xval;
 
2018
        int zpi = (op >> 0) & 0x7f;
 
2019
        if (zpi != 7)
 
2020
                dau_write_pi_double(zpi, res);
 
2021
        dau_set_val_flags((op >> 21) & 3, res);
 
2022
}
 
2023
 
 
2024
 
 
2025
void dsp32c_device::d1_0px(UINT32 op)
 
2026
{
 
2027
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
2028
        double yval = dau_read_pi_double_2nd(op >> 7, 0, xval);
2009
2029
        double res = yval;
2010
2030
        int zpi = (op >> 0) & 0x7f;
2011
2031
        if (zpi != 7)
2012
 
                dau_write_pi_double(cpustate, zpi, res);
2013
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
 
2032
                dau_write_pi_double(zpi, res);
 
2033
        dau_set_val_flags((op >> 21) & 3, res);
2014
2034
        (void)xval;
2015
2035
}
2016
2036
 
2017
2037
 
2018
 
static void d1_0mx(dsp32_state *cpustate, UINT32 op)
 
2038
void dsp32c_device::d1_0mx(UINT32 op)
2019
2039
{
2020
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
2021
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 0, xval);
 
2040
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
2041
        double yval = dau_read_pi_double_2nd(op >> 7, 0, xval);
2022
2042
        double res = -yval;
2023
2043
        int zpi = (op >> 0) & 0x7f;
2024
2044
        if (zpi != 7)
2025
 
                dau_write_pi_double(cpustate, zpi, res);
2026
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
 
2045
                dau_write_pi_double(zpi, res);
 
2046
        dau_set_val_flags((op >> 21) & 3, res);
2027
2047
        (void)xval;
2028
2048
}
2029
2049
 
2030
2050
 
2031
 
static void d1_1pp(dsp32_state *cpustate, UINT32 op)
2032
 
{
2033
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
2034
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 0, xval);
2035
 
        double res = yval + xval;
2036
 
        int zpi = (op >> 0) & 0x7f;
2037
 
        if (zpi != 7)
2038
 
                dau_write_pi_double(cpustate, zpi, res);
2039
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
2040
 
}
2041
 
 
2042
 
 
2043
 
static void d1_1pm(dsp32_state *cpustate, UINT32 op)
2044
 
{
2045
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
2046
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 0, xval);
2047
 
        double res = yval - xval;
2048
 
        int zpi = (op >> 0) & 0x7f;
2049
 
        if (zpi != 7)
2050
 
                dau_write_pi_double(cpustate, zpi, res);
2051
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
2052
 
}
2053
 
 
2054
 
 
2055
 
static void d1_1mp(dsp32_state *cpustate, UINT32 op)
2056
 
{
2057
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
2058
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 0, xval);
2059
 
        double res = -yval + xval;
2060
 
        int zpi = (op >> 0) & 0x7f;
2061
 
        if (zpi != 7)
2062
 
                dau_write_pi_double(cpustate, zpi, res);
2063
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
2064
 
}
2065
 
 
2066
 
 
2067
 
static void d1_1mm(dsp32_state *cpustate, UINT32 op)
2068
 
{
2069
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
2070
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 0, xval);
2071
 
        double res = -yval - xval;
2072
 
        int zpi = (op >> 0) & 0x7f;
2073
 
        if (zpi != 7)
2074
 
                dau_write_pi_double(cpustate, zpi, res);
2075
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
2076
 
}
2077
 
 
2078
 
 
2079
 
static void d1_aMppr(dsp32_state *cpustate, UINT32 op)
2080
 
{
2081
 
        unimplemented(cpustate, op);
2082
 
}
2083
 
 
2084
 
 
2085
 
static void d1_aMpmr(dsp32_state *cpustate, UINT32 op)
2086
 
{
2087
 
        unimplemented(cpustate, op);
2088
 
}
2089
 
 
2090
 
 
2091
 
static void d1_aMmpr(dsp32_state *cpustate, UINT32 op)
2092
 
{
2093
 
        unimplemented(cpustate, op);
2094
 
}
2095
 
 
2096
 
 
2097
 
static void d1_aMmmr(dsp32_state *cpustate, UINT32 op)
2098
 
{
2099
 
        unimplemented(cpustate, op);
2100
 
}
2101
 
 
2102
 
 
2103
 
 
2104
 
/***************************************************************************
2105
 
    DAU FORM 2 IMPLEMENTATION
2106
 
***************************************************************************/
2107
 
 
2108
 
static void d2_aMpp(dsp32_state *cpustate, UINT32 op)
2109
 
{
2110
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
2111
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 1, xval);
2112
 
        double res = cpustate->a[(op >> 26) & 7] + yval * xval;
2113
 
        int zpi = (op >> 0) & 0x7f;
2114
 
        if (zpi != 7)
2115
 
                dau_write_pi_double(cpustate, zpi, yval);
2116
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
2117
 
}
2118
 
 
2119
 
 
2120
 
static void d2_aMpm(dsp32_state *cpustate, UINT32 op)
2121
 
{
2122
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
2123
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 1, xval);
2124
 
        double res = cpustate->a[(op >> 26) & 7] - yval * xval;
2125
 
        int zpi = (op >> 0) & 0x7f;
2126
 
        if (zpi != 7)
2127
 
                dau_write_pi_double(cpustate, zpi, yval);
2128
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
2129
 
}
2130
 
 
2131
 
 
2132
 
static void d2_aMmp(dsp32_state *cpustate, UINT32 op)
2133
 
{
2134
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
2135
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 1, xval);
2136
 
        double res = -cpustate->a[(op >> 26) & 7] + yval * xval;
2137
 
        int zpi = (op >> 0) & 0x7f;
2138
 
        if (zpi != 7)
2139
 
                dau_write_pi_double(cpustate, zpi, yval);
2140
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
2141
 
}
2142
 
 
2143
 
 
2144
 
static void d2_aMmm(dsp32_state *cpustate, UINT32 op)
2145
 
{
2146
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
2147
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 1, xval);
2148
 
        double res = -cpustate->a[(op >> 26) & 7] - yval * xval;
2149
 
        int zpi = (op >> 0) & 0x7f;
2150
 
        if (zpi != 7)
2151
 
                dau_write_pi_double(cpustate, zpi, yval);
2152
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
2153
 
}
2154
 
 
2155
 
 
2156
 
static void d2_aMppr(dsp32_state *cpustate, UINT32 op)
2157
 
{
2158
 
        unimplemented(cpustate, op);
2159
 
}
2160
 
 
2161
 
 
2162
 
static void d2_aMpmr(dsp32_state *cpustate, UINT32 op)
2163
 
{
2164
 
        unimplemented(cpustate, op);
2165
 
}
2166
 
 
2167
 
 
2168
 
static void d2_aMmpr(dsp32_state *cpustate, UINT32 op)
2169
 
{
2170
 
        unimplemented(cpustate, op);
2171
 
}
2172
 
 
2173
 
 
2174
 
static void d2_aMmmr(dsp32_state *cpustate, UINT32 op)
2175
 
{
2176
 
        unimplemented(cpustate, op);
2177
 
}
2178
 
 
2179
 
 
2180
 
 
2181
 
/***************************************************************************
2182
 
    DAU FORM 3 IMPLEMENTATION
2183
 
***************************************************************************/
2184
 
 
2185
 
static void d3_aMpp(dsp32_state *cpustate, UINT32 op)
2186
 
{
2187
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
2188
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 1, xval);
2189
 
        double res = cpustate->a[(op >> 26) & 7] + yval * xval;
2190
 
        int zpi = (op >> 0) & 0x7f;
2191
 
        if (zpi != 7)
2192
 
                dau_write_pi_double(cpustate, zpi, res);
2193
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
2194
 
}
2195
 
 
2196
 
 
2197
 
static void d3_aMpm(dsp32_state *cpustate, UINT32 op)
2198
 
{
2199
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
2200
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 1, xval);
2201
 
        double res = cpustate->a[(op >> 26) & 7] - yval * xval;
2202
 
        int zpi = (op >> 0) & 0x7f;
2203
 
        if (zpi != 7)
2204
 
                dau_write_pi_double(cpustate, zpi, res);
2205
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
2206
 
}
2207
 
 
2208
 
 
2209
 
static void d3_aMmp(dsp32_state *cpustate, UINT32 op)
2210
 
{
2211
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
2212
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 1, xval);
2213
 
        double res = -cpustate->a[(op >> 26) & 7] + yval * xval;
2214
 
        int zpi = (op >> 0) & 0x7f;
2215
 
        if (zpi != 7)
2216
 
                dau_write_pi_double(cpustate, zpi, res);
2217
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
2218
 
}
2219
 
 
2220
 
 
2221
 
static void d3_aMmm(dsp32_state *cpustate, UINT32 op)
2222
 
{
2223
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
2224
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 1, xval);
2225
 
        double res = -cpustate->a[(op >> 26) & 7] - yval * xval;
2226
 
        int zpi = (op >> 0) & 0x7f;
2227
 
        if (zpi != 7)
2228
 
                dau_write_pi_double(cpustate, zpi, res);
2229
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
2230
 
}
2231
 
 
2232
 
 
2233
 
static void d3_aMppr(dsp32_state *cpustate, UINT32 op)
2234
 
{
2235
 
        unimplemented(cpustate, op);
2236
 
}
2237
 
 
2238
 
 
2239
 
static void d3_aMpmr(dsp32_state *cpustate, UINT32 op)
2240
 
{
2241
 
        unimplemented(cpustate, op);
2242
 
}
2243
 
 
2244
 
 
2245
 
static void d3_aMmpr(dsp32_state *cpustate, UINT32 op)
2246
 
{
2247
 
        unimplemented(cpustate, op);
2248
 
}
2249
 
 
2250
 
 
2251
 
static void d3_aMmmr(dsp32_state *cpustate, UINT32 op)
2252
 
{
2253
 
        unimplemented(cpustate, op);
2254
 
}
2255
 
 
2256
 
 
2257
 
 
2258
 
/***************************************************************************
2259
 
    DAU FORM 4 IMPLEMENTATION
2260
 
***************************************************************************/
2261
 
 
2262
 
static void d4_pp(dsp32_state *cpustate, UINT32 op)
2263
 
{
2264
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
2265
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 0, xval);
2266
 
        double res = yval + xval;
2267
 
        int zpi = (op >> 0) & 0x7f;
2268
 
        if (zpi != 7)
2269
 
                dau_write_pi_double(cpustate, zpi, yval);
2270
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
2271
 
}
2272
 
 
2273
 
 
2274
 
static void d4_pm(dsp32_state *cpustate, UINT32 op)
2275
 
{
2276
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
2277
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 0, xval);
2278
 
        double res = yval - xval;
2279
 
        int zpi = (op >> 0) & 0x7f;
2280
 
        if (zpi != 7)
2281
 
                dau_write_pi_double(cpustate, zpi, yval);
2282
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
2283
 
}
2284
 
 
2285
 
 
2286
 
static void d4_mp(dsp32_state *cpustate, UINT32 op)
2287
 
{
2288
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
2289
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 0, xval);
2290
 
        double res = -yval + xval;
2291
 
        int zpi = (op >> 0) & 0x7f;
2292
 
        if (zpi != 7)
2293
 
                dau_write_pi_double(cpustate, zpi, yval);
2294
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
2295
 
}
2296
 
 
2297
 
 
2298
 
static void d4_mm(dsp32_state *cpustate, UINT32 op)
2299
 
{
2300
 
        double xval = dau_read_pi_double_1st(cpustate, op >> 14, 1);
2301
 
        double yval = dau_read_pi_double_2nd(cpustate, op >> 7, 0, xval);
2302
 
        double res = -yval - xval;
2303
 
        int zpi = (op >> 0) & 0x7f;
2304
 
        if (zpi != 7)
2305
 
                dau_write_pi_double(cpustate, zpi, yval);
2306
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
2307
 
}
2308
 
 
2309
 
 
2310
 
static void d4_ppr(dsp32_state *cpustate, UINT32 op)
2311
 
{
2312
 
        unimplemented(cpustate, op);
2313
 
}
2314
 
 
2315
 
 
2316
 
static void d4_pmr(dsp32_state *cpustate, UINT32 op)
2317
 
{
2318
 
        unimplemented(cpustate, op);
2319
 
}
2320
 
 
2321
 
 
2322
 
static void d4_mpr(dsp32_state *cpustate, UINT32 op)
2323
 
{
2324
 
        unimplemented(cpustate, op);
2325
 
}
2326
 
 
2327
 
 
2328
 
static void d4_mmr(dsp32_state *cpustate, UINT32 op)
2329
 
{
2330
 
        unimplemented(cpustate, op);
2331
 
}
2332
 
 
2333
 
 
2334
 
 
2335
 
/***************************************************************************
2336
 
    DAU FORM 5 IMPLEMENTATION
2337
 
***************************************************************************/
2338
 
 
2339
 
static void d5_ic(dsp32_state *cpustate, UINT32 op)
2340
 
{
2341
 
        unimplemented(cpustate, op);
2342
 
}
2343
 
 
2344
 
 
2345
 
static void d5_oc(dsp32_state *cpustate, UINT32 op)
2346
 
{
2347
 
        unimplemented(cpustate, op);
2348
 
}
2349
 
 
2350
 
 
2351
 
static void d5_float(dsp32_state *cpustate, UINT32 op)
2352
 
{
2353
 
        double res = (double)(INT16)dau_read_pi_2bytes(cpustate, op >> 7);
2354
 
        int zpi = (op >> 0) & 0x7f;
2355
 
        if (zpi != 7)
2356
 
                dau_write_pi_double(cpustate, zpi, res);
2357
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
2358
 
}
2359
 
 
2360
 
 
2361
 
static void d5_int(dsp32_state *cpustate, UINT32 op)
2362
 
{
2363
 
        double val = dau_read_pi_double_1st(cpustate, op >> 7, 0);
 
2051
void dsp32c_device::d1_1pp(UINT32 op)
 
2052
{
 
2053
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
2054
        double yval = dau_read_pi_double_2nd(op >> 7, 0, xval);
 
2055
        double res = yval + xval;
 
2056
        int zpi = (op >> 0) & 0x7f;
 
2057
        if (zpi != 7)
 
2058
                dau_write_pi_double(zpi, res);
 
2059
        dau_set_val_flags((op >> 21) & 3, res);
 
2060
}
 
2061
 
 
2062
 
 
2063
void dsp32c_device::d1_1pm(UINT32 op)
 
2064
{
 
2065
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
2066
        double yval = dau_read_pi_double_2nd(op >> 7, 0, xval);
 
2067
        double res = yval - xval;
 
2068
        int zpi = (op >> 0) & 0x7f;
 
2069
        if (zpi != 7)
 
2070
                dau_write_pi_double(zpi, res);
 
2071
        dau_set_val_flags((op >> 21) & 3, res);
 
2072
}
 
2073
 
 
2074
 
 
2075
void dsp32c_device::d1_1mp(UINT32 op)
 
2076
{
 
2077
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
2078
        double yval = dau_read_pi_double_2nd(op >> 7, 0, xval);
 
2079
        double res = -yval + xval;
 
2080
        int zpi = (op >> 0) & 0x7f;
 
2081
        if (zpi != 7)
 
2082
                dau_write_pi_double(zpi, res);
 
2083
        dau_set_val_flags((op >> 21) & 3, res);
 
2084
}
 
2085
 
 
2086
 
 
2087
void dsp32c_device::d1_1mm(UINT32 op)
 
2088
{
 
2089
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
2090
        double yval = dau_read_pi_double_2nd(op >> 7, 0, xval);
 
2091
        double res = -yval - xval;
 
2092
        int zpi = (op >> 0) & 0x7f;
 
2093
        if (zpi != 7)
 
2094
                dau_write_pi_double(zpi, res);
 
2095
        dau_set_val_flags((op >> 21) & 3, res);
 
2096
}
 
2097
 
 
2098
 
 
2099
void dsp32c_device::d1_aMppr(UINT32 op)
 
2100
{
 
2101
        unimplemented(op);
 
2102
}
 
2103
 
 
2104
 
 
2105
void dsp32c_device::d1_aMpmr(UINT32 op)
 
2106
{
 
2107
        unimplemented(op);
 
2108
}
 
2109
 
 
2110
 
 
2111
void dsp32c_device::d1_aMmpr(UINT32 op)
 
2112
{
 
2113
        unimplemented(op);
 
2114
}
 
2115
 
 
2116
 
 
2117
void dsp32c_device::d1_aMmmr(UINT32 op)
 
2118
{
 
2119
        unimplemented(op);
 
2120
}
 
2121
 
 
2122
 
 
2123
 
 
2124
//**************************************************************************
 
2125
//  DAU FORM 2 IMPLEMENTATION
 
2126
//**************************************************************************
 
2127
 
 
2128
void dsp32c_device::d2_aMpp(UINT32 op)
 
2129
{
 
2130
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
2131
        double yval = dau_read_pi_double_2nd(op >> 7, 1, xval);
 
2132
        double res = m_a[(op >> 26) & 7] + yval * xval;
 
2133
        int zpi = (op >> 0) & 0x7f;
 
2134
        if (zpi != 7)
 
2135
                dau_write_pi_double(zpi, yval);
 
2136
        dau_set_val_flags((op >> 21) & 3, res);
 
2137
}
 
2138
 
 
2139
 
 
2140
void dsp32c_device::d2_aMpm(UINT32 op)
 
2141
{
 
2142
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
2143
        double yval = dau_read_pi_double_2nd(op >> 7, 1, xval);
 
2144
        double res = m_a[(op >> 26) & 7] - yval * xval;
 
2145
        int zpi = (op >> 0) & 0x7f;
 
2146
        if (zpi != 7)
 
2147
                dau_write_pi_double(zpi, yval);
 
2148
        dau_set_val_flags((op >> 21) & 3, res);
 
2149
}
 
2150
 
 
2151
 
 
2152
void dsp32c_device::d2_aMmp(UINT32 op)
 
2153
{
 
2154
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
2155
        double yval = dau_read_pi_double_2nd(op >> 7, 1, xval);
 
2156
        double res = -m_a[(op >> 26) & 7] + yval * xval;
 
2157
        int zpi = (op >> 0) & 0x7f;
 
2158
        if (zpi != 7)
 
2159
                dau_write_pi_double(zpi, yval);
 
2160
        dau_set_val_flags((op >> 21) & 3, res);
 
2161
}
 
2162
 
 
2163
 
 
2164
void dsp32c_device::d2_aMmm(UINT32 op)
 
2165
{
 
2166
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
2167
        double yval = dau_read_pi_double_2nd(op >> 7, 1, xval);
 
2168
        double res = -m_a[(op >> 26) & 7] - yval * xval;
 
2169
        int zpi = (op >> 0) & 0x7f;
 
2170
        if (zpi != 7)
 
2171
                dau_write_pi_double(zpi, yval);
 
2172
        dau_set_val_flags((op >> 21) & 3, res);
 
2173
}
 
2174
 
 
2175
 
 
2176
void dsp32c_device::d2_aMppr(UINT32 op)
 
2177
{
 
2178
        unimplemented(op);
 
2179
}
 
2180
 
 
2181
 
 
2182
void dsp32c_device::d2_aMpmr(UINT32 op)
 
2183
{
 
2184
        unimplemented(op);
 
2185
}
 
2186
 
 
2187
 
 
2188
void dsp32c_device::d2_aMmpr(UINT32 op)
 
2189
{
 
2190
        unimplemented(op);
 
2191
}
 
2192
 
 
2193
 
 
2194
void dsp32c_device::d2_aMmmr(UINT32 op)
 
2195
{
 
2196
        unimplemented(op);
 
2197
}
 
2198
 
 
2199
 
 
2200
 
 
2201
//**************************************************************************
 
2202
//  DAU FORM 3 IMPLEMENTATION
 
2203
//**************************************************************************
 
2204
 
 
2205
void dsp32c_device::d3_aMpp(UINT32 op)
 
2206
{
 
2207
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
2208
        double yval = dau_read_pi_double_2nd(op >> 7, 1, xval);
 
2209
        double res = m_a[(op >> 26) & 7] + yval * xval;
 
2210
        int zpi = (op >> 0) & 0x7f;
 
2211
        if (zpi != 7)
 
2212
                dau_write_pi_double(zpi, res);
 
2213
        dau_set_val_flags((op >> 21) & 3, res);
 
2214
}
 
2215
 
 
2216
 
 
2217
void dsp32c_device::d3_aMpm(UINT32 op)
 
2218
{
 
2219
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
2220
        double yval = dau_read_pi_double_2nd(op >> 7, 1, xval);
 
2221
        double res = m_a[(op >> 26) & 7] - yval * xval;
 
2222
        int zpi = (op >> 0) & 0x7f;
 
2223
        if (zpi != 7)
 
2224
                dau_write_pi_double(zpi, res);
 
2225
        dau_set_val_flags((op >> 21) & 3, res);
 
2226
}
 
2227
 
 
2228
 
 
2229
void dsp32c_device::d3_aMmp(UINT32 op)
 
2230
{
 
2231
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
2232
        double yval = dau_read_pi_double_2nd(op >> 7, 1, xval);
 
2233
        double res = -m_a[(op >> 26) & 7] + yval * xval;
 
2234
        int zpi = (op >> 0) & 0x7f;
 
2235
        if (zpi != 7)
 
2236
                dau_write_pi_double(zpi, res);
 
2237
        dau_set_val_flags((op >> 21) & 3, res);
 
2238
}
 
2239
 
 
2240
 
 
2241
void dsp32c_device::d3_aMmm(UINT32 op)
 
2242
{
 
2243
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
2244
        double yval = dau_read_pi_double_2nd(op >> 7, 1, xval);
 
2245
        double res = -m_a[(op >> 26) & 7] - yval * xval;
 
2246
        int zpi = (op >> 0) & 0x7f;
 
2247
        if (zpi != 7)
 
2248
                dau_write_pi_double(zpi, res);
 
2249
        dau_set_val_flags((op >> 21) & 3, res);
 
2250
}
 
2251
 
 
2252
 
 
2253
void dsp32c_device::d3_aMppr(UINT32 op)
 
2254
{
 
2255
        unimplemented(op);
 
2256
}
 
2257
 
 
2258
 
 
2259
void dsp32c_device::d3_aMpmr(UINT32 op)
 
2260
{
 
2261
        unimplemented(op);
 
2262
}
 
2263
 
 
2264
 
 
2265
void dsp32c_device::d3_aMmpr(UINT32 op)
 
2266
{
 
2267
        unimplemented(op);
 
2268
}
 
2269
 
 
2270
 
 
2271
void dsp32c_device::d3_aMmmr(UINT32 op)
 
2272
{
 
2273
        unimplemented(op);
 
2274
}
 
2275
 
 
2276
 
 
2277
 
 
2278
//**************************************************************************
 
2279
//  DAU FORM 4 IMPLEMENTATION
 
2280
//**************************************************************************
 
2281
 
 
2282
void dsp32c_device::d4_pp(UINT32 op)
 
2283
{
 
2284
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
2285
        double yval = dau_read_pi_double_2nd(op >> 7, 0, xval);
 
2286
        double res = yval + xval;
 
2287
        int zpi = (op >> 0) & 0x7f;
 
2288
        if (zpi != 7)
 
2289
                dau_write_pi_double(zpi, yval);
 
2290
        dau_set_val_flags((op >> 21) & 3, res);
 
2291
}
 
2292
 
 
2293
 
 
2294
void dsp32c_device::d4_pm(UINT32 op)
 
2295
{
 
2296
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
2297
        double yval = dau_read_pi_double_2nd(op >> 7, 0, xval);
 
2298
        double res = yval - xval;
 
2299
        int zpi = (op >> 0) & 0x7f;
 
2300
        if (zpi != 7)
 
2301
                dau_write_pi_double(zpi, yval);
 
2302
        dau_set_val_flags((op >> 21) & 3, res);
 
2303
}
 
2304
 
 
2305
 
 
2306
void dsp32c_device::d4_mp(UINT32 op)
 
2307
{
 
2308
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
2309
        double yval = dau_read_pi_double_2nd(op >> 7, 0, xval);
 
2310
        double res = -yval + xval;
 
2311
        int zpi = (op >> 0) & 0x7f;
 
2312
        if (zpi != 7)
 
2313
                dau_write_pi_double(zpi, yval);
 
2314
        dau_set_val_flags((op >> 21) & 3, res);
 
2315
}
 
2316
 
 
2317
 
 
2318
void dsp32c_device::d4_mm(UINT32 op)
 
2319
{
 
2320
        double xval = dau_read_pi_double_1st(op >> 14, 1);
 
2321
        double yval = dau_read_pi_double_2nd(op >> 7, 0, xval);
 
2322
        double res = -yval - xval;
 
2323
        int zpi = (op >> 0) & 0x7f;
 
2324
        if (zpi != 7)
 
2325
                dau_write_pi_double(zpi, yval);
 
2326
        dau_set_val_flags((op >> 21) & 3, res);
 
2327
}
 
2328
 
 
2329
 
 
2330
void dsp32c_device::d4_ppr(UINT32 op)
 
2331
{
 
2332
        unimplemented(op);
 
2333
}
 
2334
 
 
2335
 
 
2336
void dsp32c_device::d4_pmr(UINT32 op)
 
2337
{
 
2338
        unimplemented(op);
 
2339
}
 
2340
 
 
2341
 
 
2342
void dsp32c_device::d4_mpr(UINT32 op)
 
2343
{
 
2344
        unimplemented(op);
 
2345
}
 
2346
 
 
2347
 
 
2348
void dsp32c_device::d4_mmr(UINT32 op)
 
2349
{
 
2350
        unimplemented(op);
 
2351
}
 
2352
 
 
2353
 
 
2354
 
 
2355
//**************************************************************************
 
2356
//  DAU FORM 5 IMPLEMENTATION
 
2357
//**************************************************************************
 
2358
 
 
2359
void dsp32c_device::d5_ic(UINT32 op)
 
2360
{
 
2361
        unimplemented(op);
 
2362
}
 
2363
 
 
2364
 
 
2365
void dsp32c_device::d5_oc(UINT32 op)
 
2366
{
 
2367
        unimplemented(op);
 
2368
}
 
2369
 
 
2370
 
 
2371
void dsp32c_device::d5_float(UINT32 op)
 
2372
{
 
2373
        double res = (double)(INT16)dau_read_pi_2bytes(op >> 7);
 
2374
        int zpi = (op >> 0) & 0x7f;
 
2375
        if (zpi != 7)
 
2376
                dau_write_pi_double(zpi, res);
 
2377
        dau_set_val_flags((op >> 21) & 3, res);
 
2378
}
 
2379
 
 
2380
 
 
2381
void dsp32c_device::d5_int(UINT32 op)
 
2382
{
 
2383
        double val = dau_read_pi_double_1st(op >> 7, 0);
2364
2384
        int zpi = (op >> 0) & 0x7f;
2365
2385
        INT16 res;
2366
 
        if (!(cpustate->DAUC & 0x10)) val = floor(val + 0.5);
 
2386
        if (!(DAUC & 0x10)) val = floor(val + 0.5);
2367
2387
        else val = ceil(val - 0.5);
2368
2388
        res = (INT16)val;
2369
2389
        if (zpi != 7)
2370
 
                dau_write_pi_2bytes(cpustate, zpi, res);
2371
 
        dau_set_val_noflags(cpustate, (op >> 21) & 3, dsp_to_double(res << 16));
 
2390
                dau_write_pi_2bytes(zpi, res);
 
2391
        dau_set_val_noflags((op >> 21) & 3, dsp_to_double(res << 16));
2372
2392
}
2373
2393
 
2374
2394
 
2375
 
static void d5_round(dsp32_state *cpustate, UINT32 op)
 
2395
void dsp32c_device::d5_round(UINT32 op)
2376
2396
{
2377
 
        double res = (double)(float)dau_read_pi_double_1st(cpustate, op >> 7, 0);
 
2397
        double res = (double)(float)dau_read_pi_double_1st(op >> 7, 0);
2378
2398
        int zpi = (op >> 0) & 0x7f;
2379
2399
        if (zpi != 7)
2380
 
                dau_write_pi_double(cpustate, zpi, res);
2381
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
 
2400
                dau_write_pi_double(zpi, res);
 
2401
        dau_set_val_flags((op >> 21) & 3, res);
2382
2402
}
2383
2403
 
2384
2404
 
2385
 
static void d5_ifalt(dsp32_state *cpustate, UINT32 op)
 
2405
void dsp32c_device::d5_ifalt(UINT32 op)
2386
2406
{
2387
2407
        int ar = (op >> 21) & 3;
2388
 
        double res = cpustate->a[ar];
 
2408
        double res = m_a[ar];
2389
2409
        int zpi = (op >> 0) & 0x7f;
2390
2410
        if (NFLAG)
2391
 
                res = dau_read_pi_double_1st(cpustate, op >> 7, 0);
 
2411
                res = dau_read_pi_double_1st(op >> 7, 0);
2392
2412
        if (zpi != 7)
2393
 
                dau_write_pi_double(cpustate, zpi, res);
2394
 
        dau_set_val_noflags(cpustate, ar, res);
 
2413
                dau_write_pi_double(zpi, res);
 
2414
        dau_set_val_noflags(ar, res);
2395
2415
}
2396
2416
 
2397
2417
 
2398
 
static void d5_ifaeq(dsp32_state *cpustate, UINT32 op)
 
2418
void dsp32c_device::d5_ifaeq(UINT32 op)
2399
2419
{
2400
2420
        int ar = (op >> 21) & 3;
2401
 
        double res = cpustate->a[ar];
 
2421
        double res = m_a[ar];
2402
2422
        int zpi = (op >> 0) & 0x7f;
2403
2423
        if (ZFLAG)
2404
 
                res = dau_read_pi_double_1st(cpustate, op >> 7, 0);
 
2424
                res = dau_read_pi_double_1st(op >> 7, 0);
2405
2425
        if (zpi != 7)
2406
 
                dau_write_pi_double(cpustate, zpi, res);
2407
 
        dau_set_val_noflags(cpustate, ar, res);
 
2426
                dau_write_pi_double(zpi, res);
 
2427
        dau_set_val_noflags(ar, res);
2408
2428
}
2409
2429
 
2410
2430
 
2411
 
static void d5_ifagt(dsp32_state *cpustate, UINT32 op)
 
2431
void dsp32c_device::d5_ifagt(UINT32 op)
2412
2432
{
2413
2433
        int ar = (op >> 21) & 3;
2414
 
        double res = cpustate->a[ar];
 
2434
        double res = m_a[ar];
2415
2435
        int zpi = (op >> 0) & 0x7f;
2416
2436
        if (!NFLAG && !ZFLAG)
2417
 
                res = dau_read_pi_double_1st(cpustate, op >> 7, 0);
 
2437
                res = dau_read_pi_double_1st(op >> 7, 0);
2418
2438
        if (zpi != 7)
2419
 
                dau_write_pi_double(cpustate, zpi, res);
2420
 
        dau_set_val_noflags(cpustate, ar, res);
 
2439
                dau_write_pi_double(zpi, res);
 
2440
        dau_set_val_noflags(ar, res);
2421
2441
}
2422
2442
 
2423
2443
 
2424
 
static void d5_float24(dsp32_state *cpustate, UINT32 op)
 
2444
void dsp32c_device::d5_float24(UINT32 op)
2425
2445
{
2426
 
        double res = (double)((INT32)(dau_read_pi_4bytes(cpustate, op >> 7) << 8) >> 8);
 
2446
        double res = (double)((INT32)(dau_read_pi_4bytes(op >> 7) << 8) >> 8);
2427
2447
        int zpi = (op >> 0) & 0x7f;
2428
2448
        if (zpi != 7)
2429
 
                dau_write_pi_double(cpustate, zpi, res);
2430
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, res);
 
2449
                dau_write_pi_double(zpi, res);
 
2450
        dau_set_val_flags((op >> 21) & 3, res);
2431
2451
}
2432
2452
 
2433
2453
 
2434
 
static void d5_int24(dsp32_state *cpustate, UINT32 op)
 
2454
void dsp32c_device::d5_int24(UINT32 op)
2435
2455
{
2436
 
        double val = dau_read_pi_double_1st(cpustate, op >> 7, 0);
 
2456
        double val = dau_read_pi_double_1st(op >> 7, 0);
2437
2457
        int zpi = (op >> 0) & 0x7f;
2438
2458
        INT32 res;
2439
 
        if (!(cpustate->DAUC & 0x10)) val = floor(val + 0.5);
 
2459
        if (!(DAUC & 0x10)) val = floor(val + 0.5);
2440
2460
        else val = ceil(val - 0.5);
2441
2461
        res = (INT32)val;
2442
2462
        if (res > 0x7fffff) res = 0x7fffff;
2443
2463
        else if (res < -0x800000) res = -0x800000;
2444
2464
        if (zpi != 7)
2445
 
                dau_write_pi_4bytes(cpustate, zpi, (INT32)(res << 8) >> 8);
2446
 
        dau_set_val_noflags(cpustate, (op >> 21) & 3, dsp_to_double(res << 8));
2447
 
}
2448
 
 
2449
 
 
2450
 
static void d5_ieee(dsp32_state *cpustate, UINT32 op)
2451
 
{
2452
 
        unimplemented(cpustate, op);
2453
 
}
2454
 
 
2455
 
 
2456
 
static void d5_dsp(dsp32_state *cpustate, UINT32 op)
2457
 
{
2458
 
        unimplemented(cpustate, op);
2459
 
}
2460
 
 
2461
 
 
2462
 
static void d5_seed(dsp32_state *cpustate, UINT32 op)
2463
 
{
2464
 
        UINT32 val = dau_read_pi_4bytes(cpustate, op >> 7);
 
2465
                dau_write_pi_4bytes(zpi, (INT32)(res << 8) >> 8);
 
2466
        dau_set_val_noflags((op >> 21) & 3, dsp_to_double(res << 8));
 
2467
}
 
2468
 
 
2469
 
 
2470
void dsp32c_device::d5_ieee(UINT32 op)
 
2471
{
 
2472
        unimplemented(op);
 
2473
}
 
2474
 
 
2475
 
 
2476
void dsp32c_device::d5_dsp(UINT32 op)
 
2477
{
 
2478
        unimplemented(op);
 
2479
}
 
2480
 
 
2481
 
 
2482
void dsp32c_device::d5_seed(UINT32 op)
 
2483
{
 
2484
        UINT32 val = dau_read_pi_4bytes(op >> 7);
2465
2485
        INT32 res = val ^ 0x7fffffff;
2466
2486
        int zpi = (op >> 0) & 0x7f;
2467
2487
        if (zpi != 7)
2468
 
                dau_write_pi_4bytes(cpustate, zpi, res);
2469
 
        dau_set_val_flags(cpustate, (op >> 21) & 3, dsp_to_double((INT32)res));
 
2488
                dau_write_pi_4bytes(zpi, res);
 
2489
        dau_set_val_flags((op >> 21) & 3, dsp_to_double((INT32)res));
2470
2490
}
2471
2491
 
2472
2492
 
2473
2493
 
2474
 
/***************************************************************************
2475
 
    FUNCTION TABLE
2476
 
***************************************************************************/
 
2494
//**************************************************************************
 
2495
//  FUNCTION TABLE
 
2496
//**************************************************************************
2477
2497
 
2478
 
void (*const dsp32ops[])(dsp32_state *cpustate, UINT32 op) =
 
2498
void (dsp32c_device::*const dsp32c_device::s_dsp32ops[])(UINT32 op) =
2479
2499
{
2480
 
        nop,            goto_t,         goto_pl,        goto_mi,        goto_ne,        goto_eq,        goto_vc,        goto_vs,        /* 00 */
2481
 
        goto_cc,        goto_cs,        goto_ge,        goto_lt,        goto_gt,        goto_le,        goto_hi,        goto_ls,
2482
 
        goto_auc,       goto_aus,       goto_age,       goto_alt,       goto_ane,       goto_aeq,       goto_avc,       goto_avs,       /* 01 */
2483
 
        goto_agt,       goto_ale,       illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2484
 
        goto_ibe,       goto_ibf,       goto_obf,       goto_obe,       goto_pde,       goto_pdf,       goto_pie,       goto_pif,       /* 02 */
2485
 
        goto_syc,       goto_sys,       goto_fbc,       goto_fbs,       goto_irq1lo,goto_irq1hi,goto_irq2lo,goto_irq2hi,
2486
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 03 */
2487
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2488
 
 
2489
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 04 */
2490
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2491
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 05 */
2492
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2493
 
        dec_goto,       dec_goto,       dec_goto,       dec_goto,       dec_goto,       dec_goto,       dec_goto,       dec_goto,       /* 06 */
2494
 
        dec_goto,       dec_goto,       dec_goto,       dec_goto,       dec_goto,       dec_goto,       dec_goto,       dec_goto,
2495
 
        dec_goto,       dec_goto,       dec_goto,       dec_goto,       dec_goto,       dec_goto,       dec_goto,       dec_goto,       /* 07 */
2496
 
        dec_goto,       dec_goto,       dec_goto,       dec_goto,       dec_goto,       dec_goto,       dec_goto,       dec_goto,
2497
 
 
2498
 
        call,           call,           call,           call,           call,           call,           call,           call,           /* 08 */
2499
 
        call,           call,           call,           call,           call,           call,           call,           call,
2500
 
        call,           call,           call,           call,           call,           call,           call,           call,           /* 09 */
2501
 
        call,           call,           call,           call,           call,           call,           call,           call,
2502
 
        add_si,         add_si,         add_si,         add_si,         add_si,         add_si,         add_si,         add_si,         /* 0a */
2503
 
        add_si,         add_si,         add_si,         add_si,         add_si,         add_si,         add_si,         add_si,
2504
 
        add_si,         add_si,         add_si,         add_si,         add_si,         add_si,         add_si,         add_si,         /* 0b */
2505
 
        add_si,         add_si,         add_si,         add_si,         add_si,         add_si,         add_si,         add_si,
2506
 
 
2507
 
        add_ss,         mul2_s,         subr_ss,        addr_ss,        sub_ss,         neg_s,          andc_ss,        cmp_ss,         /* 0c */
2508
 
        xor_ss,         rcr_s,          or_ss,          rcl_s,          shr_s,          div2_s,         and_ss,         test_ss,
2509
 
        add_di,         illegal,        subr_di,        addr_di,        sub_di,         illegal,        andc_di,        cmp_di,         /* 0d */
2510
 
        xor_di,         illegal,        or_di,          illegal,        illegal,        illegal,        and_di,         test_di,
2511
 
        load_hi,        load_hi,        load_li,        load_li,        load_i,         load_i,         load_ei,        load_ei,        /* 0e */
2512
 
        store_hi,       store_hi,       store_li,       store_li,       store_i,        store_i,        store_ei,       store_ei,
2513
 
        load_hr,        load_hr,        load_lr,        load_lr,        load_r,         load_r,         load_er,        load_er,        /* 0f */
2514
 
        store_hr,       store_hr,       store_lr,       store_lr,       store_r,        store_r,        store_er,       store_er,
2515
 
 
2516
 
        d1_aMpp,        d1_aMpp,        d1_aMpp,        d1_aMpp,        d1_aMpm,        d1_aMpm,        d1_aMpm,        d1_aMpm,        /* 10 */
2517
 
        d1_aMmp,        d1_aMmp,        d1_aMmp,        d1_aMmp,        d1_aMmm,        d1_aMmm,        d1_aMmm,        d1_aMmm,
2518
 
        d1_aMppr,       d1_aMppr,       d1_aMppr,       d1_aMppr,       d1_aMpmr,       d1_aMpmr,       d1_aMpmr,       d1_aMpmr,       /* 11 */
2519
 
        d1_aMmpr,       d1_aMmpr,       d1_aMmpr,       d1_aMmpr,       d1_aMmmr,       d1_aMmmr,       d1_aMmmr,       d1_aMmmr,
2520
 
        d1_aMpp,        d1_aMpp,        d1_aMpp,        d1_aMpp,        d1_aMpm,        d1_aMpm,        d1_aMpm,        d1_aMpm,        /* 12 */
2521
 
        d1_aMmp,        d1_aMmp,        d1_aMmp,        d1_aMmp,        d1_aMmm,        d1_aMmm,        d1_aMmm,        d1_aMmm,
2522
 
        d1_aMppr,       d1_aMppr,       d1_aMppr,       d1_aMppr,       d1_aMpmr,       d1_aMpmr,       d1_aMpmr,       d1_aMpmr,       /* 13 */
2523
 
        d1_aMmpr,       d1_aMmpr,       d1_aMmpr,       d1_aMmpr,       d1_aMmmr,       d1_aMmmr,       d1_aMmmr,       d1_aMmmr,
2524
 
 
2525
 
        d1_aMpp,        d1_aMpp,        d1_aMpp,        d1_aMpp,        d1_aMpm,        d1_aMpm,        d1_aMpm,        d1_aMpm,        /* 14 */
2526
 
        d1_aMmp,        d1_aMmp,        d1_aMmp,        d1_aMmp,        d1_aMmm,        d1_aMmm,        d1_aMmm,        d1_aMmm,
2527
 
        d1_aMppr,       d1_aMppr,       d1_aMppr,       d1_aMppr,       d1_aMpmr,       d1_aMpmr,       d1_aMpmr,       d1_aMpmr,       /* 15 */
2528
 
        d1_aMmpr,       d1_aMmpr,       d1_aMmpr,       d1_aMmpr,       d1_aMmmr,       d1_aMmmr,       d1_aMmmr,       d1_aMmmr,
2529
 
        d1_aMpp,        d1_aMpp,        d1_aMpp,        d1_aMpp,        d1_aMpm,        d1_aMpm,        d1_aMpm,        d1_aMpm,        /* 16 */
2530
 
        d1_aMmp,        d1_aMmp,        d1_aMmp,        d1_aMmp,        d1_aMmm,        d1_aMmm,        d1_aMmm,        d1_aMmm,
2531
 
        d1_aMppr,       d1_aMppr,       d1_aMppr,       d1_aMppr,       d1_aMpmr,       d1_aMpmr,       d1_aMpmr,       d1_aMpmr,       /* 17 */
2532
 
        d1_aMmpr,       d1_aMmpr,       d1_aMmpr,       d1_aMmpr,       d1_aMmmr,       d1_aMmmr,       d1_aMmmr,       d1_aMmmr,
2533
 
 
2534
 
        d1_0px,         d1_0px,         d1_0px,         d1_0px,         d1_0px,         d1_0px,         d1_0px,         d1_0px,         /* 18 */
2535
 
        d1_0mx,         d1_0mx,         d1_0mx,         d1_0mx,         d1_0mx,         d1_0mx,         d1_0mx,         d1_0mx,
2536
 
        d1_aMppr,       d1_aMppr,       d1_aMppr,       d1_aMppr,       d1_aMpmr,       d1_aMpmr,       d1_aMpmr,       d1_aMpmr,       /* 19 */
2537
 
        d1_aMmpr,       d1_aMmpr,       d1_aMmpr,       d1_aMmpr,       d1_aMmmr,       d1_aMmmr,       d1_aMmmr,       d1_aMmmr,
2538
 
        d1_1pp,         d1_1pp,         d1_1pp,         d1_1pp,         d1_1pm,         d1_1pm,         d1_1pm,         d1_1pm,         /* 1a */
2539
 
        d1_1mp,         d1_1mp,         d1_1mp,         d1_1mp,         d1_1mm,         d1_1mm,         d1_1mm,         d1_1mm,
2540
 
        d1_aMppr,       d1_aMppr,       d1_aMppr,       d1_aMppr,       d1_aMpmr,       d1_aMpmr,       d1_aMpmr,       d1_aMpmr,       /* 1b */
2541
 
        d1_aMmpr,       d1_aMmpr,       d1_aMmpr,       d1_aMmpr,       d1_aMmmr,       d1_aMmmr,       d1_aMmmr,       d1_aMmmr,
2542
 
 
2543
 
        d4_pp,          d4_pp,          d4_pp,          d4_pp,          d4_pm,          d4_pm,          d4_pm,          d4_pm,          /* 1c */
2544
 
        d4_mp,          d4_mp,          d4_mp,          d4_mp,          d4_mm,          d4_mm,          d4_mm,          d4_mm,
2545
 
        d4_ppr,         d4_ppr,         d4_ppr,         d4_ppr,         d4_pmr,         d4_pmr,         d4_pmr,         d4_pmr,         /* 1d */
2546
 
        d4_mpr,         d4_mpr,         d4_mpr,         d4_mpr,         d4_mmr,         d4_mmr,         d4_mmr,         d4_mmr,
2547
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 1e */
2548
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2549
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 1f */
2550
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2551
 
 
2552
 
        d2_aMpp,        d2_aMpp,        d2_aMpp,        d2_aMpp,        d2_aMpm,        d2_aMpm,        d2_aMpm,        d2_aMpm,        /* 20 */
2553
 
        d2_aMmp,        d2_aMmp,        d2_aMmp,        d2_aMmp,        d2_aMmm,        d2_aMmm,        d2_aMmm,        d2_aMmm,
2554
 
        d2_aMppr,       d2_aMppr,       d2_aMppr,       d2_aMppr,       d2_aMpmr,       d2_aMpmr,       d2_aMpmr,       d2_aMpmr,       /* 21 */
2555
 
        d2_aMmpr,       d2_aMmpr,       d2_aMmpr,       d2_aMmpr,       d2_aMmmr,       d2_aMmmr,       d2_aMmmr,       d2_aMmmr,
2556
 
        d2_aMpp,        d2_aMpp,        d2_aMpp,        d2_aMpp,        d2_aMpm,        d2_aMpm,        d2_aMpm,        d2_aMpm,        /* 22 */
2557
 
        d2_aMmp,        d2_aMmp,        d2_aMmp,        d2_aMmp,        d2_aMmm,        d2_aMmm,        d2_aMmm,        d2_aMmm,
2558
 
        d2_aMppr,       d2_aMppr,       d2_aMppr,       d2_aMppr,       d2_aMpmr,       d2_aMpmr,       d2_aMpmr,       d2_aMpmr,       /* 23 */
2559
 
        d2_aMmpr,       d2_aMmpr,       d2_aMmpr,       d2_aMmpr,       d2_aMmmr,       d2_aMmmr,       d2_aMmmr,       d2_aMmmr,
2560
 
 
2561
 
        d2_aMpp,        d2_aMpp,        d2_aMpp,        d2_aMpp,        d2_aMpm,        d2_aMpm,        d2_aMpm,        d2_aMpm,        /* 24 */
2562
 
        d2_aMmp,        d2_aMmp,        d2_aMmp,        d2_aMmp,        d2_aMmm,        d2_aMmm,        d2_aMmm,        d2_aMmm,
2563
 
        d2_aMppr,       d2_aMppr,       d2_aMppr,       d2_aMppr,       d2_aMpmr,       d2_aMpmr,       d2_aMpmr,       d2_aMpmr,       /* 25 */
2564
 
        d2_aMmpr,       d2_aMmpr,       d2_aMmpr,       d2_aMmpr,       d2_aMmmr,       d2_aMmmr,       d2_aMmmr,       d2_aMmmr,
2565
 
        d2_aMpp,        d2_aMpp,        d2_aMpp,        d2_aMpp,        d2_aMpm,        d2_aMpm,        d2_aMpm,        d2_aMpm,        /* 26 */
2566
 
        d2_aMmp,        d2_aMmp,        d2_aMmp,        d2_aMmp,        d2_aMmm,        d2_aMmm,        d2_aMmm,        d2_aMmm,
2567
 
        d2_aMppr,       d2_aMppr,       d2_aMppr,       d2_aMppr,       d2_aMpmr,       d2_aMpmr,       d2_aMpmr,       d2_aMpmr,       /* 27 */
2568
 
        d2_aMmpr,       d2_aMmpr,       d2_aMmpr,       d2_aMmpr,       d2_aMmmr,       d2_aMmmr,       d2_aMmmr,       d2_aMmmr,
2569
 
 
2570
 
        d2_aMpp,        d2_aMpp,        d2_aMpp,        d2_aMpp,        d2_aMpm,        d2_aMpm,        d2_aMpm,        d2_aMpm,        /* 28 */
2571
 
        d2_aMmp,        d2_aMmp,        d2_aMmp,        d2_aMmp,        d2_aMmm,        d2_aMmm,        d2_aMmm,        d2_aMmm,
2572
 
        d2_aMppr,       d2_aMppr,       d2_aMppr,       d2_aMppr,       d2_aMpmr,       d2_aMpmr,       d2_aMpmr,       d2_aMpmr,       /* 29 */
2573
 
        d2_aMmpr,       d2_aMmpr,       d2_aMmpr,       d2_aMmpr,       d2_aMmmr,       d2_aMmmr,       d2_aMmmr,       d2_aMmmr,
2574
 
        d2_aMpp,        d2_aMpp,        d2_aMpp,        d2_aMpp,        d2_aMpm,        d2_aMpm,        d2_aMpm,        d2_aMpm,        /* 2a */
2575
 
        d2_aMmp,        d2_aMmp,        d2_aMmp,        d2_aMmp,        d2_aMmm,        d2_aMmm,        d2_aMmm,        d2_aMmm,
2576
 
        d2_aMppr,       d2_aMppr,       d2_aMppr,       d2_aMppr,       d2_aMpmr,       d2_aMpmr,       d2_aMpmr,       d2_aMpmr,       /* 2b */
2577
 
        d2_aMmpr,       d2_aMmpr,       d2_aMmpr,       d2_aMmpr,       d2_aMmmr,       d2_aMmmr,       d2_aMmmr,       d2_aMmmr,
2578
 
 
2579
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 2c */
2580
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2581
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 2d */
2582
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2583
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 2e */
2584
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2585
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 2f */
2586
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2587
 
 
2588
 
        d3_aMpp,        d3_aMpp,        d3_aMpp,        d3_aMpp,        d3_aMpm,        d3_aMpm,        d3_aMpm,        d3_aMpm,        /* 30 */
2589
 
        d3_aMmp,        d3_aMmp,        d3_aMmp,        d3_aMmp,        d3_aMmm,        d3_aMmm,        d3_aMmm,        d3_aMmm,
2590
 
        d3_aMppr,       d3_aMppr,       d3_aMppr,       d3_aMppr,       d3_aMpmr,       d3_aMpmr,       d3_aMpmr,       d3_aMpmr,       /* 31 */
2591
 
        d3_aMmpr,       d3_aMmpr,       d3_aMmpr,       d3_aMmpr,       d3_aMmmr,       d3_aMmmr,       d3_aMmmr,       d3_aMmmr,
2592
 
        d3_aMpp,        d3_aMpp,        d3_aMpp,        d3_aMpp,        d3_aMpm,        d3_aMpm,        d3_aMpm,        d3_aMpm,        /* 32 */
2593
 
        d3_aMmp,        d3_aMmp,        d3_aMmp,        d3_aMmp,        d3_aMmm,        d3_aMmm,        d3_aMmm,        d3_aMmm,
2594
 
        d3_aMppr,       d3_aMppr,       d3_aMppr,       d3_aMppr,       d3_aMpmr,       d3_aMpmr,       d3_aMpmr,       d3_aMpmr,       /* 33 */
2595
 
        d3_aMmpr,       d3_aMmpr,       d3_aMmpr,       d3_aMmpr,       d3_aMmmr,       d3_aMmmr,       d3_aMmmr,       d3_aMmmr,
2596
 
 
2597
 
        d3_aMpp,        d3_aMpp,        d3_aMpp,        d3_aMpp,        d3_aMpm,        d3_aMpm,        d3_aMpm,        d3_aMpm,        /* 34 */
2598
 
        d3_aMmp,        d3_aMmp,        d3_aMmp,        d3_aMmp,        d3_aMmm,        d3_aMmm,        d3_aMmm,        d3_aMmm,
2599
 
        d3_aMppr,       d3_aMppr,       d3_aMppr,       d3_aMppr,       d3_aMpmr,       d3_aMpmr,       d3_aMpmr,       d3_aMpmr,       /* 35 */
2600
 
        d3_aMmpr,       d3_aMmpr,       d3_aMmpr,       d3_aMmpr,       d3_aMmmr,       d3_aMmmr,       d3_aMmmr,       d3_aMmmr,
2601
 
        d3_aMpp,        d3_aMpp,        d3_aMpp,        d3_aMpp,        d3_aMpm,        d3_aMpm,        d3_aMpm,        d3_aMpm,        /* 36 */
2602
 
        d3_aMmp,        d3_aMmp,        d3_aMmp,        d3_aMmp,        d3_aMmm,        d3_aMmm,        d3_aMmm,        d3_aMmm,
2603
 
        d3_aMppr,       d3_aMppr,       d3_aMppr,       d3_aMppr,       d3_aMpmr,       d3_aMpmr,       d3_aMpmr,       d3_aMpmr,       /* 37 */
2604
 
        d3_aMmpr,       d3_aMmpr,       d3_aMmpr,       d3_aMmpr,       d3_aMmmr,       d3_aMmmr,       d3_aMmmr,       d3_aMmmr,
2605
 
 
2606
 
        d3_aMpp,        d3_aMpp,        d3_aMpp,        d3_aMpp,        d3_aMpm,        d3_aMpm,        d3_aMpm,        d3_aMpm,        /* 38 */
2607
 
        d3_aMmp,        d3_aMmp,        d3_aMmp,        d3_aMmp,        d3_aMmm,        d3_aMmm,        d3_aMmm,        d3_aMmm,
2608
 
        d3_aMppr,       d3_aMppr,       d3_aMppr,       d3_aMppr,       d3_aMpmr,       d3_aMpmr,       d3_aMpmr,       d3_aMpmr,       /* 39 */
2609
 
        d3_aMmpr,       d3_aMmpr,       d3_aMmpr,       d3_aMmpr,       d3_aMmmr,       d3_aMmmr,       d3_aMmmr,       d3_aMmmr,
2610
 
        d3_aMpp,        d3_aMpp,        d3_aMpp,        d3_aMpp,        d3_aMpm,        d3_aMpm,        d3_aMpm,        d3_aMpm,        /* 3a */
2611
 
        d3_aMmp,        d3_aMmp,        d3_aMmp,        d3_aMmp,        d3_aMmm,        d3_aMmm,        d3_aMmm,        d3_aMmm,
2612
 
        d3_aMppr,       d3_aMppr,       d3_aMppr,       d3_aMppr,       d3_aMpmr,       d3_aMpmr,       d3_aMpmr,       d3_aMpmr,       /* 3b */
2613
 
        d3_aMmpr,       d3_aMmpr,       d3_aMmpr,       d3_aMmpr,       d3_aMmmr,       d3_aMmmr,       d3_aMmmr,       d3_aMmmr,
2614
 
 
2615
 
        d5_ic,          d5_ic,          d5_ic,          d5_ic,          d5_oc,          d5_oc,          d5_oc,          d5_oc,          /* 3c */
2616
 
        d5_float,       d5_float,       d5_float,       d5_float,       d5_int,         d5_int,         d5_int,         d5_int,
2617
 
        d5_round,       d5_round,       d5_round,       d5_round,       d5_ifalt,       d5_ifalt,       d5_ifalt,       d5_ifalt,       /* 3d */
2618
 
        d5_ifaeq,       d5_ifaeq,       d5_ifaeq,       d5_ifaeq,       d5_ifagt,       d5_ifagt,       d5_ifagt,       d5_ifagt,
2619
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 3e */
2620
 
        d5_float24,     d5_float24,     d5_float24,     d5_float24,     d5_int24,       d5_int24,       d5_int24,       d5_int24,
2621
 
        d5_ieee,        d5_ieee,        d5_ieee,        d5_ieee,        d5_dsp,         d5_dsp,         d5_dsp,         d5_dsp,         /* 3f */
2622
 
        d5_seed,        d5_seed,        d5_seed,        d5_seed,        illegal,        illegal,        illegal,        illegal,
2623
 
 
2624
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 40 */
2625
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2626
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 41 */
2627
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2628
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 42 */
2629
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2630
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 43 */
2631
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2632
 
 
2633
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 44 */
2634
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2635
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 45 */
2636
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2637
 
        do_i,           do_r,           illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 46 */
2638
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2639
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 47 */
2640
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2641
 
 
2642
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 48 */
2643
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2644
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 49 */
2645
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2646
 
        adde_si,        adde_si,        adde_si,        adde_si,        adde_si,        adde_si,        adde_si,        adde_si,        /* 4a */
2647
 
        adde_si,        adde_si,        adde_si,        adde_si,        adde_si,        adde_si,        adde_si,        adde_si,
2648
 
        adde_si,        adde_si,        adde_si,        adde_si,        adde_si,        adde_si,        adde_si,        adde_si,        /* 4b */
2649
 
        adde_si,        adde_si,        adde_si,        adde_si,        adde_si,        adde_si,        adde_si,        adde_si,
2650
 
 
2651
 
        adde_ss,        mul2e_s,        subre_ss,       addre_ss,       sube_ss,        nege_s,         andce_ss,       cmpe_ss,        /* 4c */
2652
 
        xore_ss,        rcre_s,         ore_ss,         rcle_s,         shre_s,         div2e_s,        ande_ss,        teste_ss,
2653
 
        adde_di,        illegal,        subre_di,       addre_di,       sube_di,        illegal,        andce_di,       cmpe_di,        /* 4d */
2654
 
        xore_di,        illegal,        ore_di,         illegal,        illegal,        illegal,        ande_di,        teste_di,
2655
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 4e */
2656
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2657
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        /* 4f */
2658
 
        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,        illegal,
2659
 
 
2660
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         /* 50 */
2661
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,
2662
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         /* 51 */
2663
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,
2664
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         /* 52 */
2665
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,
2666
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         /* 53 */
2667
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,
2668
 
 
2669
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         /* 54 */
2670
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,
2671
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         /* 55 */
2672
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,
2673
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         /* 56 */
2674
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,
2675
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         /* 57 */
2676
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,
2677
 
 
2678
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         /* 58 */
2679
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,
2680
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         /* 59 */
2681
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,
2682
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         /* 5a */
2683
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,
2684
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         /* 5b */
2685
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,
2686
 
 
2687
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         /* 5c */
2688
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,
2689
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         /* 5d */
2690
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,
2691
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         /* 5e */
2692
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,
2693
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         /* 5f */
2694
 
        goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,         goto24,
2695
 
 
2696
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,         /* 60 */
2697
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,
2698
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,         /* 61 */
2699
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,
2700
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,         /* 62 */
2701
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,
2702
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,         /* 63 */
2703
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,
2704
 
 
2705
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,         /* 64 */
2706
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,
2707
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,         /* 65 */
2708
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,
2709
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,         /* 66 */
2710
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,
2711
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,         /* 67 */
2712
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,
2713
 
 
2714
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,         /* 68 */
2715
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,
2716
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,         /* 69 */
2717
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,
2718
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,         /* 6a */
2719
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,
2720
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,         /* 6b */
2721
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,
2722
 
 
2723
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,         /* 6c */
2724
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,
2725
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,         /* 6d */
2726
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,
2727
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,         /* 6e */
2728
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,
2729
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,         /* 6f */
2730
 
        load24,         load24,         load24,         load24,         load24,         load24,         load24,         load24,
2731
 
 
2732
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,         /* 70 */
2733
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,
2734
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,         /* 71 */
2735
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,
2736
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,         /* 72 */
2737
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,
2738
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,         /* 73 */
2739
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,
2740
 
 
2741
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,         /* 74 */
2742
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,
2743
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,         /* 75 */
2744
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,
2745
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,         /* 76 */
2746
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,
2747
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,         /* 77 */
2748
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,
2749
 
 
2750
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,         /* 78 */
2751
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,
2752
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,         /* 79 */
2753
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,
2754
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,         /* 7a */
2755
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,
2756
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,         /* 7b */
2757
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,
2758
 
 
2759
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,         /* 7c */
2760
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,
2761
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,         /* 7d */
2762
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,
2763
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,         /* 7e */
2764
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,
2765
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24,         /* 7f */
2766
 
        call24,         call24,         call24,         call24,         call24,         call24,         call24,         call24
 
2500
        &dsp32c_device::nop,            &dsp32c_device::goto_t,         &dsp32c_device::goto_pl,        &dsp32c_device::goto_mi,        &dsp32c_device::goto_ne,        &dsp32c_device::goto_eq,        &dsp32c_device::goto_vc,        &dsp32c_device::goto_vs,        // 00
 
2501
        &dsp32c_device::goto_cc,        &dsp32c_device::goto_cs,        &dsp32c_device::goto_ge,        &dsp32c_device::goto_lt,        &dsp32c_device::goto_gt,        &dsp32c_device::goto_le,        &dsp32c_device::goto_hi,        &dsp32c_device::goto_ls,
 
2502
        &dsp32c_device::goto_auc,       &dsp32c_device::goto_aus,       &dsp32c_device::goto_age,       &dsp32c_device::goto_alt,       &dsp32c_device::goto_ane,       &dsp32c_device::goto_aeq,       &dsp32c_device::goto_avc,       &dsp32c_device::goto_avs,       // 01
 
2503
        &dsp32c_device::goto_agt,       &dsp32c_device::goto_ale,       &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2504
        &dsp32c_device::goto_ibe,       &dsp32c_device::goto_ibf,       &dsp32c_device::goto_obf,       &dsp32c_device::goto_obe,       &dsp32c_device::goto_pde,       &dsp32c_device::goto_pdf,       &dsp32c_device::goto_pie,       &dsp32c_device::goto_pif,       // 02
 
2505
        &dsp32c_device::goto_syc,       &dsp32c_device::goto_sys,       &dsp32c_device::goto_fbc,       &dsp32c_device::goto_fbs,       &dsp32c_device::goto_irq1lo,&dsp32c_device::goto_irq1hi,&dsp32c_device::goto_irq2lo,&dsp32c_device::goto_irq2hi,
 
2506
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 03
 
2507
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2508
 
 
2509
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 04
 
2510
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2511
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 05
 
2512
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2513
        &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       // 06
 
2514
        &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,
 
2515
        &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       // 07
 
2516
        &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,       &dsp32c_device::dec_goto,
 
2517
 
 
2518
        &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           // 08
 
2519
        &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,
 
2520
        &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           // 09
 
2521
        &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,           &dsp32c_device::call,
 
2522
        &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         // 0a
 
2523
        &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,
 
2524
        &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         // 0b
 
2525
        &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,         &dsp32c_device::add_si,
 
2526
 
 
2527
        &dsp32c_device::add_ss,         &dsp32c_device::mul2_s,         &dsp32c_device::subr_ss,        &dsp32c_device::addr_ss,        &dsp32c_device::sub_ss,         &dsp32c_device::neg_s,          &dsp32c_device::andc_ss,        &dsp32c_device::cmp_ss,         // 0c
 
2528
        &dsp32c_device::xor_ss,         &dsp32c_device::rcr_s,          &dsp32c_device::or_ss,          &dsp32c_device::rcl_s,          &dsp32c_device::shr_s,          &dsp32c_device::div2_s,         &dsp32c_device::and_ss,         &dsp32c_device::test_ss,
 
2529
        &dsp32c_device::add_di,         &dsp32c_device::illegal,        &dsp32c_device::subr_di,        &dsp32c_device::addr_di,        &dsp32c_device::sub_di,         &dsp32c_device::illegal,        &dsp32c_device::andc_di,        &dsp32c_device::cmp_di,         // 0d
 
2530
        &dsp32c_device::xor_di,         &dsp32c_device::illegal,        &dsp32c_device::or_di,          &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::and_di,         &dsp32c_device::test_di,
 
2531
        &dsp32c_device::load_hi,        &dsp32c_device::load_hi,        &dsp32c_device::load_li,        &dsp32c_device::load_li,        &dsp32c_device::load_i,         &dsp32c_device::load_i,         &dsp32c_device::load_ei,        &dsp32c_device::load_ei,        // 0e
 
2532
        &dsp32c_device::store_hi,       &dsp32c_device::store_hi,       &dsp32c_device::store_li,       &dsp32c_device::store_li,       &dsp32c_device::store_i,        &dsp32c_device::store_i,        &dsp32c_device::store_ei,       &dsp32c_device::store_ei,
 
2533
        &dsp32c_device::load_hr,        &dsp32c_device::load_hr,        &dsp32c_device::load_lr,        &dsp32c_device::load_lr,        &dsp32c_device::load_r,         &dsp32c_device::load_r,         &dsp32c_device::load_er,        &dsp32c_device::load_er,        // 0f
 
2534
        &dsp32c_device::store_hr,       &dsp32c_device::store_hr,       &dsp32c_device::store_lr,       &dsp32c_device::store_lr,       &dsp32c_device::store_r,        &dsp32c_device::store_r,        &dsp32c_device::store_er,       &dsp32c_device::store_er,
 
2535
 
 
2536
        &dsp32c_device::d1_aMpp,        &dsp32c_device::d1_aMpp,        &dsp32c_device::d1_aMpp,        &dsp32c_device::d1_aMpp,        &dsp32c_device::d1_aMpm,        &dsp32c_device::d1_aMpm,        &dsp32c_device::d1_aMpm,        &dsp32c_device::d1_aMpm,        // 10
 
2537
        &dsp32c_device::d1_aMmp,        &dsp32c_device::d1_aMmp,        &dsp32c_device::d1_aMmp,        &dsp32c_device::d1_aMmp,        &dsp32c_device::d1_aMmm,        &dsp32c_device::d1_aMmm,        &dsp32c_device::d1_aMmm,        &dsp32c_device::d1_aMmm,
 
2538
        &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMpmr,       &dsp32c_device::d1_aMpmr,       &dsp32c_device::d1_aMpmr,       &dsp32c_device::d1_aMpmr,       // 11
 
2539
        &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmmr,       &dsp32c_device::d1_aMmmr,       &dsp32c_device::d1_aMmmr,       &dsp32c_device::d1_aMmmr,
 
2540
        &dsp32c_device::d1_aMpp,        &dsp32c_device::d1_aMpp,        &dsp32c_device::d1_aMpp,        &dsp32c_device::d1_aMpp,        &dsp32c_device::d1_aMpm,        &dsp32c_device::d1_aMpm,        &dsp32c_device::d1_aMpm,        &dsp32c_device::d1_aMpm,        // 12
 
2541
        &dsp32c_device::d1_aMmp,        &dsp32c_device::d1_aMmp,        &dsp32c_device::d1_aMmp,        &dsp32c_device::d1_aMmp,        &dsp32c_device::d1_aMmm,        &dsp32c_device::d1_aMmm,        &dsp32c_device::d1_aMmm,        &dsp32c_device::d1_aMmm,
 
2542
        &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMpmr,       &dsp32c_device::d1_aMpmr,       &dsp32c_device::d1_aMpmr,       &dsp32c_device::d1_aMpmr,       // 13
 
2543
        &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmmr,       &dsp32c_device::d1_aMmmr,       &dsp32c_device::d1_aMmmr,       &dsp32c_device::d1_aMmmr,
 
2544
 
 
2545
        &dsp32c_device::d1_aMpp,        &dsp32c_device::d1_aMpp,        &dsp32c_device::d1_aMpp,        &dsp32c_device::d1_aMpp,        &dsp32c_device::d1_aMpm,        &dsp32c_device::d1_aMpm,        &dsp32c_device::d1_aMpm,        &dsp32c_device::d1_aMpm,        // 14
 
2546
        &dsp32c_device::d1_aMmp,        &dsp32c_device::d1_aMmp,        &dsp32c_device::d1_aMmp,        &dsp32c_device::d1_aMmp,        &dsp32c_device::d1_aMmm,        &dsp32c_device::d1_aMmm,        &dsp32c_device::d1_aMmm,        &dsp32c_device::d1_aMmm,
 
2547
        &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMpmr,       &dsp32c_device::d1_aMpmr,       &dsp32c_device::d1_aMpmr,       &dsp32c_device::d1_aMpmr,       // 15
 
2548
        &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmmr,       &dsp32c_device::d1_aMmmr,       &dsp32c_device::d1_aMmmr,       &dsp32c_device::d1_aMmmr,
 
2549
        &dsp32c_device::d1_aMpp,        &dsp32c_device::d1_aMpp,        &dsp32c_device::d1_aMpp,        &dsp32c_device::d1_aMpp,        &dsp32c_device::d1_aMpm,        &dsp32c_device::d1_aMpm,        &dsp32c_device::d1_aMpm,        &dsp32c_device::d1_aMpm,        // 16
 
2550
        &dsp32c_device::d1_aMmp,        &dsp32c_device::d1_aMmp,        &dsp32c_device::d1_aMmp,        &dsp32c_device::d1_aMmp,        &dsp32c_device::d1_aMmm,        &dsp32c_device::d1_aMmm,        &dsp32c_device::d1_aMmm,        &dsp32c_device::d1_aMmm,
 
2551
        &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMpmr,       &dsp32c_device::d1_aMpmr,       &dsp32c_device::d1_aMpmr,       &dsp32c_device::d1_aMpmr,       // 17
 
2552
        &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmmr,       &dsp32c_device::d1_aMmmr,       &dsp32c_device::d1_aMmmr,       &dsp32c_device::d1_aMmmr,
 
2553
 
 
2554
        &dsp32c_device::d1_0px,         &dsp32c_device::d1_0px,         &dsp32c_device::d1_0px,         &dsp32c_device::d1_0px,         &dsp32c_device::d1_0px,         &dsp32c_device::d1_0px,         &dsp32c_device::d1_0px,         &dsp32c_device::d1_0px,         // 18
 
2555
        &dsp32c_device::d1_0mx,         &dsp32c_device::d1_0mx,         &dsp32c_device::d1_0mx,         &dsp32c_device::d1_0mx,         &dsp32c_device::d1_0mx,         &dsp32c_device::d1_0mx,         &dsp32c_device::d1_0mx,         &dsp32c_device::d1_0mx,
 
2556
        &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMpmr,       &dsp32c_device::d1_aMpmr,       &dsp32c_device::d1_aMpmr,       &dsp32c_device::d1_aMpmr,       // 19
 
2557
        &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmmr,       &dsp32c_device::d1_aMmmr,       &dsp32c_device::d1_aMmmr,       &dsp32c_device::d1_aMmmr,
 
2558
        &dsp32c_device::d1_1pp,         &dsp32c_device::d1_1pp,         &dsp32c_device::d1_1pp,         &dsp32c_device::d1_1pp,         &dsp32c_device::d1_1pm,         &dsp32c_device::d1_1pm,         &dsp32c_device::d1_1pm,         &dsp32c_device::d1_1pm,         // 1a
 
2559
        &dsp32c_device::d1_1mp,         &dsp32c_device::d1_1mp,         &dsp32c_device::d1_1mp,         &dsp32c_device::d1_1mp,         &dsp32c_device::d1_1mm,         &dsp32c_device::d1_1mm,         &dsp32c_device::d1_1mm,         &dsp32c_device::d1_1mm,
 
2560
        &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMppr,       &dsp32c_device::d1_aMpmr,       &dsp32c_device::d1_aMpmr,       &dsp32c_device::d1_aMpmr,       &dsp32c_device::d1_aMpmr,       // 1b
 
2561
        &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmpr,       &dsp32c_device::d1_aMmmr,       &dsp32c_device::d1_aMmmr,       &dsp32c_device::d1_aMmmr,       &dsp32c_device::d1_aMmmr,
 
2562
 
 
2563
        &dsp32c_device::d4_pp,          &dsp32c_device::d4_pp,          &dsp32c_device::d4_pp,          &dsp32c_device::d4_pp,          &dsp32c_device::d4_pm,          &dsp32c_device::d4_pm,          &dsp32c_device::d4_pm,          &dsp32c_device::d4_pm,          // 1c
 
2564
        &dsp32c_device::d4_mp,          &dsp32c_device::d4_mp,          &dsp32c_device::d4_mp,          &dsp32c_device::d4_mp,          &dsp32c_device::d4_mm,          &dsp32c_device::d4_mm,          &dsp32c_device::d4_mm,          &dsp32c_device::d4_mm,
 
2565
        &dsp32c_device::d4_ppr,         &dsp32c_device::d4_ppr,         &dsp32c_device::d4_ppr,         &dsp32c_device::d4_ppr,         &dsp32c_device::d4_pmr,         &dsp32c_device::d4_pmr,         &dsp32c_device::d4_pmr,         &dsp32c_device::d4_pmr,         // 1d
 
2566
        &dsp32c_device::d4_mpr,         &dsp32c_device::d4_mpr,         &dsp32c_device::d4_mpr,         &dsp32c_device::d4_mpr,         &dsp32c_device::d4_mmr,         &dsp32c_device::d4_mmr,         &dsp32c_device::d4_mmr,         &dsp32c_device::d4_mmr,
 
2567
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 1e
 
2568
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2569
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 1f
 
2570
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2571
 
 
2572
        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpm,        &dsp32c_device::d2_aMpm,        &dsp32c_device::d2_aMpm,        &dsp32c_device::d2_aMpm,        // 20
 
2573
        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmm,        &dsp32c_device::d2_aMmm,        &dsp32c_device::d2_aMmm,        &dsp32c_device::d2_aMmm,
 
2574
        &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMpmr,       &dsp32c_device::d2_aMpmr,       &dsp32c_device::d2_aMpmr,       &dsp32c_device::d2_aMpmr,       // 21
 
2575
        &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmmr,       &dsp32c_device::d2_aMmmr,       &dsp32c_device::d2_aMmmr,       &dsp32c_device::d2_aMmmr,
 
2576
        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpm,        &dsp32c_device::d2_aMpm,        &dsp32c_device::d2_aMpm,        &dsp32c_device::d2_aMpm,        // 22
 
2577
        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmm,        &dsp32c_device::d2_aMmm,        &dsp32c_device::d2_aMmm,        &dsp32c_device::d2_aMmm,
 
2578
        &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMpmr,       &dsp32c_device::d2_aMpmr,       &dsp32c_device::d2_aMpmr,       &dsp32c_device::d2_aMpmr,       // 23
 
2579
        &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmmr,       &dsp32c_device::d2_aMmmr,       &dsp32c_device::d2_aMmmr,       &dsp32c_device::d2_aMmmr,
 
2580
 
 
2581
        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpm,        &dsp32c_device::d2_aMpm,        &dsp32c_device::d2_aMpm,        &dsp32c_device::d2_aMpm,        // 24
 
2582
        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmm,        &dsp32c_device::d2_aMmm,        &dsp32c_device::d2_aMmm,        &dsp32c_device::d2_aMmm,
 
2583
        &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMpmr,       &dsp32c_device::d2_aMpmr,       &dsp32c_device::d2_aMpmr,       &dsp32c_device::d2_aMpmr,       // 25
 
2584
        &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmmr,       &dsp32c_device::d2_aMmmr,       &dsp32c_device::d2_aMmmr,       &dsp32c_device::d2_aMmmr,
 
2585
        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpm,        &dsp32c_device::d2_aMpm,        &dsp32c_device::d2_aMpm,        &dsp32c_device::d2_aMpm,        // 26
 
2586
        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmm,        &dsp32c_device::d2_aMmm,        &dsp32c_device::d2_aMmm,        &dsp32c_device::d2_aMmm,
 
2587
        &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMpmr,       &dsp32c_device::d2_aMpmr,       &dsp32c_device::d2_aMpmr,       &dsp32c_device::d2_aMpmr,       // 27
 
2588
        &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmmr,       &dsp32c_device::d2_aMmmr,       &dsp32c_device::d2_aMmmr,       &dsp32c_device::d2_aMmmr,
 
2589
 
 
2590
        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpm,        &dsp32c_device::d2_aMpm,        &dsp32c_device::d2_aMpm,        &dsp32c_device::d2_aMpm,        // 28
 
2591
        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmm,        &dsp32c_device::d2_aMmm,        &dsp32c_device::d2_aMmm,        &dsp32c_device::d2_aMmm,
 
2592
        &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMpmr,       &dsp32c_device::d2_aMpmr,       &dsp32c_device::d2_aMpmr,       &dsp32c_device::d2_aMpmr,       // 29
 
2593
        &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmmr,       &dsp32c_device::d2_aMmmr,       &dsp32c_device::d2_aMmmr,       &dsp32c_device::d2_aMmmr,
 
2594
        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpp,        &dsp32c_device::d2_aMpm,        &dsp32c_device::d2_aMpm,        &dsp32c_device::d2_aMpm,        &dsp32c_device::d2_aMpm,        // 2a
 
2595
        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmp,        &dsp32c_device::d2_aMmm,        &dsp32c_device::d2_aMmm,        &dsp32c_device::d2_aMmm,        &dsp32c_device::d2_aMmm,
 
2596
        &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMppr,       &dsp32c_device::d2_aMpmr,       &dsp32c_device::d2_aMpmr,       &dsp32c_device::d2_aMpmr,       &dsp32c_device::d2_aMpmr,       // 2b
 
2597
        &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmpr,       &dsp32c_device::d2_aMmmr,       &dsp32c_device::d2_aMmmr,       &dsp32c_device::d2_aMmmr,       &dsp32c_device::d2_aMmmr,
 
2598
 
 
2599
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 2c
 
2600
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2601
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 2d
 
2602
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2603
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 2e
 
2604
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2605
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 2f
 
2606
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2607
 
 
2608
        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpm,        &dsp32c_device::d3_aMpm,        &dsp32c_device::d3_aMpm,        &dsp32c_device::d3_aMpm,        // 30
 
2609
        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmm,        &dsp32c_device::d3_aMmm,        &dsp32c_device::d3_aMmm,        &dsp32c_device::d3_aMmm,
 
2610
        &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMpmr,       &dsp32c_device::d3_aMpmr,       &dsp32c_device::d3_aMpmr,       &dsp32c_device::d3_aMpmr,       // 31
 
2611
        &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmmr,       &dsp32c_device::d3_aMmmr,       &dsp32c_device::d3_aMmmr,       &dsp32c_device::d3_aMmmr,
 
2612
        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpm,        &dsp32c_device::d3_aMpm,        &dsp32c_device::d3_aMpm,        &dsp32c_device::d3_aMpm,        // 32
 
2613
        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmm,        &dsp32c_device::d3_aMmm,        &dsp32c_device::d3_aMmm,        &dsp32c_device::d3_aMmm,
 
2614
        &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMpmr,       &dsp32c_device::d3_aMpmr,       &dsp32c_device::d3_aMpmr,       &dsp32c_device::d3_aMpmr,       // 33
 
2615
        &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmmr,       &dsp32c_device::d3_aMmmr,       &dsp32c_device::d3_aMmmr,       &dsp32c_device::d3_aMmmr,
 
2616
 
 
2617
        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpm,        &dsp32c_device::d3_aMpm,        &dsp32c_device::d3_aMpm,        &dsp32c_device::d3_aMpm,        // 34
 
2618
        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmm,        &dsp32c_device::d3_aMmm,        &dsp32c_device::d3_aMmm,        &dsp32c_device::d3_aMmm,
 
2619
        &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMpmr,       &dsp32c_device::d3_aMpmr,       &dsp32c_device::d3_aMpmr,       &dsp32c_device::d3_aMpmr,       // 35
 
2620
        &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmmr,       &dsp32c_device::d3_aMmmr,       &dsp32c_device::d3_aMmmr,       &dsp32c_device::d3_aMmmr,
 
2621
        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpm,        &dsp32c_device::d3_aMpm,        &dsp32c_device::d3_aMpm,        &dsp32c_device::d3_aMpm,        // 36
 
2622
        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmm,        &dsp32c_device::d3_aMmm,        &dsp32c_device::d3_aMmm,        &dsp32c_device::d3_aMmm,
 
2623
        &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMpmr,       &dsp32c_device::d3_aMpmr,       &dsp32c_device::d3_aMpmr,       &dsp32c_device::d3_aMpmr,       // 37
 
2624
        &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmmr,       &dsp32c_device::d3_aMmmr,       &dsp32c_device::d3_aMmmr,       &dsp32c_device::d3_aMmmr,
 
2625
 
 
2626
        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpm,        &dsp32c_device::d3_aMpm,        &dsp32c_device::d3_aMpm,        &dsp32c_device::d3_aMpm,        // 38
 
2627
        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmm,        &dsp32c_device::d3_aMmm,        &dsp32c_device::d3_aMmm,        &dsp32c_device::d3_aMmm,
 
2628
        &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMpmr,       &dsp32c_device::d3_aMpmr,       &dsp32c_device::d3_aMpmr,       &dsp32c_device::d3_aMpmr,       // 39
 
2629
        &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmmr,       &dsp32c_device::d3_aMmmr,       &dsp32c_device::d3_aMmmr,       &dsp32c_device::d3_aMmmr,
 
2630
        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpp,        &dsp32c_device::d3_aMpm,        &dsp32c_device::d3_aMpm,        &dsp32c_device::d3_aMpm,        &dsp32c_device::d3_aMpm,        // 3a
 
2631
        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmp,        &dsp32c_device::d3_aMmm,        &dsp32c_device::d3_aMmm,        &dsp32c_device::d3_aMmm,        &dsp32c_device::d3_aMmm,
 
2632
        &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMppr,       &dsp32c_device::d3_aMpmr,       &dsp32c_device::d3_aMpmr,       &dsp32c_device::d3_aMpmr,       &dsp32c_device::d3_aMpmr,       // 3b
 
2633
        &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmpr,       &dsp32c_device::d3_aMmmr,       &dsp32c_device::d3_aMmmr,       &dsp32c_device::d3_aMmmr,       &dsp32c_device::d3_aMmmr,
 
2634
 
 
2635
        &dsp32c_device::d5_ic,          &dsp32c_device::d5_ic,          &dsp32c_device::d5_ic,          &dsp32c_device::d5_ic,          &dsp32c_device::d5_oc,          &dsp32c_device::d5_oc,          &dsp32c_device::d5_oc,          &dsp32c_device::d5_oc,          // 3c
 
2636
        &dsp32c_device::d5_float,       &dsp32c_device::d5_float,       &dsp32c_device::d5_float,       &dsp32c_device::d5_float,       &dsp32c_device::d5_int,         &dsp32c_device::d5_int,         &dsp32c_device::d5_int,         &dsp32c_device::d5_int,
 
2637
        &dsp32c_device::d5_round,       &dsp32c_device::d5_round,       &dsp32c_device::d5_round,       &dsp32c_device::d5_round,       &dsp32c_device::d5_ifalt,       &dsp32c_device::d5_ifalt,       &dsp32c_device::d5_ifalt,       &dsp32c_device::d5_ifalt,       // 3d
 
2638
        &dsp32c_device::d5_ifaeq,       &dsp32c_device::d5_ifaeq,       &dsp32c_device::d5_ifaeq,       &dsp32c_device::d5_ifaeq,       &dsp32c_device::d5_ifagt,       &dsp32c_device::d5_ifagt,       &dsp32c_device::d5_ifagt,       &dsp32c_device::d5_ifagt,
 
2639
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 3e
 
2640
        &dsp32c_device::d5_float24,     &dsp32c_device::d5_float24,     &dsp32c_device::d5_float24,     &dsp32c_device::d5_float24,     &dsp32c_device::d5_int24,       &dsp32c_device::d5_int24,       &dsp32c_device::d5_int24,       &dsp32c_device::d5_int24,
 
2641
        &dsp32c_device::d5_ieee,        &dsp32c_device::d5_ieee,        &dsp32c_device::d5_ieee,        &dsp32c_device::d5_ieee,        &dsp32c_device::d5_dsp,         &dsp32c_device::d5_dsp,         &dsp32c_device::d5_dsp,         &dsp32c_device::d5_dsp,         // 3f
 
2642
        &dsp32c_device::d5_seed,        &dsp32c_device::d5_seed,        &dsp32c_device::d5_seed,        &dsp32c_device::d5_seed,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2643
 
 
2644
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 40
 
2645
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2646
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 41
 
2647
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2648
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 42
 
2649
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2650
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 43
 
2651
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2652
 
 
2653
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 44
 
2654
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2655
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 45
 
2656
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2657
        &dsp32c_device::do_i,           &dsp32c_device::do_r,           &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 46
 
2658
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2659
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 47
 
2660
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2661
 
 
2662
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 48
 
2663
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2664
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 49
 
2665
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2666
        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        // 4a
 
2667
        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,
 
2668
        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        // 4b
 
2669
        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,        &dsp32c_device::adde_si,
 
2670
 
 
2671
        &dsp32c_device::adde_ss,        &dsp32c_device::mul2e_s,        &dsp32c_device::subre_ss,       &dsp32c_device::addre_ss,       &dsp32c_device::sube_ss,        &dsp32c_device::nege_s,         &dsp32c_device::andce_ss,       &dsp32c_device::cmpe_ss,        // 4c
 
2672
        &dsp32c_device::xore_ss,        &dsp32c_device::rcre_s,         &dsp32c_device::ore_ss,         &dsp32c_device::rcle_s,         &dsp32c_device::shre_s,         &dsp32c_device::div2e_s,        &dsp32c_device::ande_ss,        &dsp32c_device::teste_ss,
 
2673
        &dsp32c_device::adde_di,        &dsp32c_device::illegal,        &dsp32c_device::subre_di,       &dsp32c_device::addre_di,       &dsp32c_device::sube_di,        &dsp32c_device::illegal,        &dsp32c_device::andce_di,       &dsp32c_device::cmpe_di,        // 4d
 
2674
        &dsp32c_device::xore_di,        &dsp32c_device::illegal,        &dsp32c_device::ore_di,         &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::ande_di,        &dsp32c_device::teste_di,
 
2675
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 4e
 
2676
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2677
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        // 4f
 
2678
        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,        &dsp32c_device::illegal,
 
2679
 
 
2680
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         // 50
 
2681
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,
 
2682
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         // 51
 
2683
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,
 
2684
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         // 52
 
2685
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,
 
2686
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         // 53
 
2687
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,
 
2688
 
 
2689
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         // 54
 
2690
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,
 
2691
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         // 55
 
2692
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,
 
2693
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         // 56
 
2694
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,
 
2695
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         // 57
 
2696
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,
 
2697
 
 
2698
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         // 58
 
2699
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,
 
2700
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         // 59
 
2701
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,
 
2702
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         // 5a
 
2703
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,
 
2704
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         // 5b
 
2705
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,
 
2706
 
 
2707
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         // 5c
 
2708
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,
 
2709
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         // 5d
 
2710
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,
 
2711
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         // 5e
 
2712
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,
 
2713
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         // 5f
 
2714
        &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,         &dsp32c_device::goto24,
 
2715
 
 
2716
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         // 60
 
2717
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,
 
2718
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         // 61
 
2719
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,
 
2720
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         // 62
 
2721
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,
 
2722
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         // 63
 
2723
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,
 
2724
 
 
2725
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         // 64
 
2726
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,
 
2727
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         // 65
 
2728
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,
 
2729
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         // 66
 
2730
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,
 
2731
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         // 67
 
2732
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,
 
2733
 
 
2734
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         // 68
 
2735
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,
 
2736
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         // 69
 
2737
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,
 
2738
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         // 6a
 
2739
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,
 
2740
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         // 6b
 
2741
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,
 
2742
 
 
2743
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         // 6c
 
2744
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,
 
2745
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         // 6d
 
2746
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,
 
2747
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         // 6e
 
2748
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,
 
2749
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         // 6f
 
2750
        &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,         &dsp32c_device::load24,
 
2751
 
 
2752
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         // 70
 
2753
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,
 
2754
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         // 71
 
2755
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,
 
2756
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         // 72
 
2757
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,
 
2758
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         // 73
 
2759
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,
 
2760
 
 
2761
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         // 74
 
2762
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,
 
2763
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         // 75
 
2764
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,
 
2765
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         // 76
 
2766
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,
 
2767
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         // 77
 
2768
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,
 
2769
 
 
2770
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         // 78
 
2771
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,
 
2772
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         // 79
 
2773
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,
 
2774
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         // 7a
 
2775
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,
 
2776
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         // 7b
 
2777
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,
 
2778
 
 
2779
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         // 7c
 
2780
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,
 
2781
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         // 7d
 
2782
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,
 
2783
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         // 7e
 
2784
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,
 
2785
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         // 7f
 
2786
        &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24,         &dsp32c_device::call24
2767
2787
};
2768
2788
 
2769
2789