Previous 15994 Revisions Next

r9061 Tuesday 7th September, 2010 at 05:55:07 UTC by Miodrag Milanović
Sync with MAME (fixes i386 drivers issue)
[src/emu]devcpu.c devintrf.c devintrf.h diexec.c diexec.h distate.c distate.h schedule.c
[src/emu/cpu/asap]asap.c asap.h asapdasm.c
[src/emu/debug]debugcmd.c

src/emu/debug/debugcmd.c
r9060r9061
364364   debug_console_register_command(machine, "softreset",   CMDFLAG_NONE, 0, 0, 1, execute_softreset);
365365   debug_console_register_command(machine, "hardreset",   CMDFLAG_NONE, 0, 0, 1, execute_hardreset);
366366
367   /* ask all the devices if they would like to register functions or symbols */
368   machine->m_devicelist.debug_setup_all();
369
370367   machine->add_notifier(MACHINE_NOTIFY_EXIT, debug_command_exit);
371368
372369   /* set up the initial debugscript if specified */
src/emu/cpu/asap/asap.c
r9060r9061
11/***************************************************************************
22
33    asap.c
4
45    Core implementation for the portable ASAP emulator.
56    ASAP = Atari Simplified Architecture Processor
67
7    Written by Aaron Giles
88    Special thanks to Mike Albaugh for clarification on a couple of fine points.
99
10****************************************************************************
11
12    Copyright Aaron Giles
13    All rights reserved.
14
15    Redistribution and use in source and binary forms, with or without
16    modification, are permitted provided that the following conditions are
17    met:
18
19        * Redistributions of source code must retain the above copyright
20          notice, this list of conditions and the following disclaimer.
21        * Redistributions in binary form must reproduce the above copyright
22          notice, this list of conditions and the following disclaimer in
23          the documentation and/or other materials provided with the
24          distribution.
25        * Neither the name 'MAME' nor the names of its contributors may be
26          used to endorse or promote products derived from this software
27          without specific prior written permission.
28
29    THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
30    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
31    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
32    DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
33    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
34    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
35    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
36    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
37    STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
38    IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
39    POSSIBILITY OF SUCH DAMAGE.
40
1041***************************************************************************/
1142
1243#include "emu.h"
r9060r9061
1445#include "asap.h"
1546
1647
17/***************************************************************************
18    CONSTANTS
19***************************************************************************/
48//**************************************************************************
49//  CONSTANTS
50//**************************************************************************
2051
21#define PS_CFLAG         0x00000001
22#define PS_VFLAG         0x00000002
23#define PS_ZFLAG         0x00000004
24#define PS_NFLAG         0x00000008
25#define PS_IFLAG         0x00000010
26#define PS_PFLAG         0x00000020
52const UINT32 PS_CFLAG         = 0x00000001;
53const UINT32 PS_VFLAG         = 0x00000002;
54const UINT32 PS_ZFLAG         = 0x00000004;
55const UINT32 PS_NFLAG         = 0x00000008;
56const UINT32 PS_IFLAG         = 0x00000010;
57const UINT32 PS_PFLAG         = 0x00000020;
2758
28#define EXCEPTION_RESET      0
29#define EXCEPTION_TRAP0      1
30#define EXCEPTION_TRAPF      2
31#define EXCEPTION_INTERRUPT   3
59const int EXCEPTION_RESET      = 0;
60const int EXCEPTION_TRAP0      = 1;
61const int EXCEPTION_TRAPF      = 2;
62const int EXCEPTION_INTERRUPT   = 3;
3263
64const int REGBASE             = 0xffe0;
3365
34#define REGBASE            0xffe0
3566
3667
37#define SET_C_ADD(A,a,b)      ((A)->cflag = (UINT32)(b) > (UINT32)(~(a)))
38#define SET_C_SUB(A,a,b)      ((A)->cflag = (UINT32)(b) <= (UINT32)(a))
39#define SET_V_ADD(A,r,a,b)      ((A)->vflag = ~((a) ^ (b)) & ((a) ^ (r)))
40#define SET_V_SUB(A,r,a,b)      ((A)->vflag =  ((a) ^ (b)) & ((a) ^ (r)))
41#define SET_ZN(A,r)            ((A)->znflag = (r))
42#define SET_ZNCV_ADD(A,r,a,b)   SET_ZN(A,r); SET_C_ADD(A,a,b); SET_V_ADD(A,r,a,b)
43#define SET_ZNCV_SUB(A,r,a,b)   SET_ZN(A,r); SET_C_SUB(A,a,b); SET_V_SUB(A,r,a,b)
68//**************************************************************************
69//  MACROS
70//**************************************************************************
4471
45#define SET_VFLAG(A,val)      ((A)->vflag = (val) << 31)
46#define SET_CFLAG(A,val)      ((A)->cflag = (val))
72#define SET_C_ADD(a,b)         (m_cflag = (UINT32)(b) > (UINT32)(~(a)))
73#define SET_C_SUB(a,b)         (m_cflag = (UINT32)(b) <= (UINT32)(a))
74#define SET_V_ADD(r,a,b)      (m_vflag = ~((a) ^ (b)) & ((a) ^ (r)))
75#define SET_V_SUB(r,a,b)      (m_vflag =  ((a) ^ (b)) & ((a) ^ (r)))
76#define SET_ZN(r)            (m_znflag = (r))
77#define SET_ZNCV_ADD(r,a,b)      SET_ZN(r); SET_C_ADD(a,b); SET_V_ADD(r,a,b)
78#define SET_ZNCV_SUB(r,a,b)      SET_ZN(r); SET_C_SUB(a,b); SET_V_SUB(r,a,b)
4779
48#define GET_FLAGS(A)         ((A)->cflag | \
49                         (((A)->vflag >> 30) & PS_VFLAG) | \
50                         (((A)->znflag == 0) << 2) | \
51                         (((A)->znflag >> 28) & PS_NFLAG) | \
52                         ((A)->iflag << 4) | \
53                         ((A)->pflag << 5))
80#define SET_VFLAG(val)         (m_vflag = (val) << 31)
81#define SET_CFLAG(val)         (m_cflag = (val))
5482
55#define SET_FLAGS(A,v)         do { \
56                           (A)->cflag = (v) & PS_CFLAG; \
57                           (A)->vflag = ((v) & PS_VFLAG) << 30; \
58                           (A)->znflag = ((v) & PS_ZFLAG) ? 0 : ((v) & PS_NFLAG) ? -1 : 1; \
59                           (A)->iflag = ((v) & PS_IFLAG) >> 4; \
60                           (A)->pflag = ((v) & PS_PFLAG) >> 5; \
83#define GET_FLAGS()            (m_cflag | \
84                         ((m_vflag >> 30) & PS_VFLAG) | \
85                         ((m_znflag == 0) << 2) | \
86                         ((m_znflag >> 28) & PS_NFLAG) | \
87                         (m_iflag << 4) | \
88                         (m_pflag << 5))
89
90#define SET_FLAGS(v)         do { \
91                           m_cflag = (v) & PS_CFLAG; \
92                           m_vflag = ((v) & PS_VFLAG) << 30; \
93                           m_znflag = ((v) & PS_ZFLAG) ? 0 : ((v) & PS_NFLAG) ? -1 : 1; \
94                           m_iflag = ((v) & PS_IFLAG) >> 4; \
95                           m_pflag = ((v) & PS_PFLAG) >> 5; \
6196                        } while (0);
6297
98#define OPCODE               (m_op >> 27)
99#define DSTREG               ((m_op >> 22) & 31)
100#define DSTVAL               m_src2val[REGBASE + DSTREG]
101#define SRC1REG               ((m_op >> 16) & 31)
102#define SRC1VAL               m_src2val[REGBASE + SRC1REG]
103#define SRC2VAL               m_src2val[m_op & 0xffff]
63104
64/***************************************************************************
65    STRUCTURES & TYPEDEFS
66***************************************************************************/
67105
68/* ASAP Registers */
69typedef struct _asap_state asap_state;
70struct _asap_state
71{
72   /* core registers */
73   UINT32      pc;
74106
75   /* expanded flags */
76   UINT32      pflag;
77   UINT32      iflag;
78   UINT32      cflag;
79   UINT32      vflag;
80   UINT32      znflag;
107//**************************************************************************
108//  STATIC OPCODE TABLES
109//**************************************************************************
81110
82   /* internal stuff */
83   PAIR      op;
84   UINT32      ppc;
85   UINT32      nextpc;
86   UINT8      irq_state;
87   int         icount;
88   device_irq_callback irq_callback;
89   address_space *program;
90   direct_read_data *direct;
91   legacy_cpu_device *device;
111const asap_device::ophandler asap_device::s_opcodetable[32][4] =
112{
113   {   &asap_device::trap0,   &asap_device::trap0,   &asap_device::trap0,   &asap_device::trap0      },
114   {   &asap_device::noop,      &asap_device::noop,      &asap_device::noop,      &asap_device::noop      },
115   {   &asap_device::bsr,      &asap_device::bsr_0,   &asap_device::bsr,      &asap_device::bsr_0      },
116   {   &asap_device::lea,      &asap_device::noop,      &asap_device::lea_c,   &asap_device::lea_c0   },
117   {   &asap_device::leah,      &asap_device::noop,      &asap_device::leah_c,   &asap_device::leah_c0   },
118   {   &asap_device::subr,      &asap_device::noop,      &asap_device::subr_c,   &asap_device::subr_c0   },
119   {   &asap_device::xor_,      &asap_device::noop,      &asap_device::xor_c,   &asap_device::xor_c0   },
120   {   &asap_device::xorn,      &asap_device::noop,      &asap_device::xorn_c,   &asap_device::xorn_c0   },
121   {   &asap_device::add,      &asap_device::noop,      &asap_device::add_c,   &asap_device::add_c0   },
122   {   &asap_device::sub,      &asap_device::noop,      &asap_device::sub_c,   &asap_device::sub_c0   },
123   {   &asap_device::addc,      &asap_device::noop,      &asap_device::addc_c,   &asap_device::addc_c0   },
124   {   &asap_device::subc,      &asap_device::noop,      &asap_device::subc_c,   &asap_device::subc_c0   },
125   {   &asap_device::and_,      &asap_device::noop,      &asap_device::and_c,   &asap_device::and_c0   },
126   {   &asap_device::andn,      &asap_device::noop,      &asap_device::andn_c,   &asap_device::andn_c0   },
127   {   &asap_device::or_,      &asap_device::noop,      &asap_device::or_c,      &asap_device::or_c0      },
128   {   &asap_device::orn,      &asap_device::noop,      &asap_device::orn_c,   &asap_device::orn_c0   },
129   {   &asap_device::ld,      &asap_device::ld_0,      &asap_device::ld_c,      &asap_device::ld_c0      },
130   {   &asap_device::ldh,      &asap_device::ldh_0,   &asap_device::ldh_c,   &asap_device::ldh_c0   },
131   {   &asap_device::lduh,      &asap_device::lduh_0,   &asap_device::lduh_c,   &asap_device::lduh_c0   },
132   {   &asap_device::sth,      &asap_device::sth_0,   &asap_device::sth_c,   &asap_device::sth_c0   },
133   {   &asap_device::st,      &asap_device::st_0,      &asap_device::st_c,      &asap_device::st_c0      },
134   {   &asap_device::ldb,      &asap_device::ldb_0,   &asap_device::ldb_c,   &asap_device::ldb_c0   },
135   {   &asap_device::ldub,      &asap_device::ldub_0,   &asap_device::ldub_c,   &asap_device::ldub_c0   },
136   {   &asap_device::stb,      &asap_device::stb_0,   &asap_device::stb_c,   &asap_device::stb_c0   },
137   {   &asap_device::ashr,      &asap_device::noop,      &asap_device::ashr_c,   &asap_device::ashr_c0   },
138   {   &asap_device::lshr,      &asap_device::noop,      &asap_device::lshr_c,   &asap_device::lshr_c0   },
139   {   &asap_device::ashl,      &asap_device::noop,      &asap_device::ashl_c,   &asap_device::ashl_c0   },
140   {   &asap_device::rotl,      &asap_device::noop,      &asap_device::rotl_c,   &asap_device::rotl_c0   },
141   {   &asap_device::getps,   &asap_device::noop,      &asap_device::getps,   &asap_device::noop      },
142   {   &asap_device::putps,   &asap_device::putps,   &asap_device::putps,   &asap_device::putps      },
143   {   &asap_device::jsr,      &asap_device::jsr_0,   &asap_device::jsr_c,   &asap_device::jsr_c0   },
144   {   &asap_device::trapf,   &asap_device::trapf,   &asap_device::trapf,   &asap_device::trapf      }
145};
92146
93   /* src2val table, registers are at the end */
94   UINT32      src2val[65536];
147const asap_device::ophandler asap_device::s_conditiontable[16] =
148{
149   &asap_device::bsp, &asap_device::bmz, &asap_device::bgt, &asap_device::ble,
150   &asap_device::bge, &asap_device::blt, &asap_device::bhi, &asap_device::bls,
151   &asap_device::bcc, &asap_device::bcs, &asap_device::bpl, &asap_device::bmi,
152   &asap_device::bne, &asap_device::beq, &asap_device::bvc, &asap_device::bvs
95153};
96154
97155
98156
99/***************************************************************************
100    PRIVATE GLOBAL VARIABLES
101***************************************************************************/
157//**************************************************************************
158//  ASAP DEVICE CONFIG
159//**************************************************************************
102160
103static void (**opcode)(asap_state *);
161//-------------------------------------------------
162//  asap_device_config - constructor
163//-------------------------------------------------
104164
165asap_device_config::asap_device_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock)
166   : cpu_device_config(mconfig, static_alloc_device_config, "ASAP", tag, owner, clock),
167     m_program_config("program", ENDIANNESS_LITTLE, 32, 32)
168{
169}
105170
106171
107/***************************************************************************
108    OPCODE TABLE
109***************************************************************************/
172//-------------------------------------------------
173//  static_alloc_device_config - allocate a new
174//  configuration object
175//-------------------------------------------------
110176
111static void noop(asap_state *);
112static void trap0(asap_state *);
113static void bsp(asap_state *);
114static void bmz(asap_state *);
115static void bgt(asap_state *);
116static void ble(asap_state *);
117static void bge(asap_state *);
118static void blt(asap_state *);
119static void bhi(asap_state *);
120static void bls(asap_state *);
121static void bcc(asap_state *);
122static void bcs(asap_state *);
123static void bpl(asap_state *);
124static void bmi(asap_state *);
125static void bne(asap_state *);
126static void beq(asap_state *);
127static void bvc(asap_state *);
128static void bvs(asap_state *);
129static void bsr(asap_state *);
130static void bsr_0(asap_state *);
131static void lea(asap_state *);
132static void lea_c(asap_state *);
133static void lea_c0(asap_state *);
134static void leah(asap_state *);
135static void leah_c(asap_state *);
136static void leah_c0(asap_state *);
137static void subr(asap_state *);
138static void subr_c(asap_state *);
139static void subr_c0(asap_state *);
140static void xor_(asap_state *);
141static void xor_c(asap_state *);
142static void xor_c0(asap_state *);
143static void xorn(asap_state *);
144static void xorn_c(asap_state *);
145static void xorn_c0(asap_state *);
146static void add(asap_state *);
147static void add_c(asap_state *);
148static void add_c0(asap_state *);
149static void sub(asap_state *);
150static void sub_c(asap_state *);
151static void sub_c0(asap_state *);
152static void addc(asap_state *);
153static void addc_c(asap_state *);
154static void addc_c0(asap_state *);
155static void subc(asap_state *);
156static void subc_c(asap_state *);
157static void subc_c0(asap_state *);
158static void and_(asap_state *);
159static void and_c(asap_state *);
160static void and_c0(asap_state *);
161static void andn(asap_state *);
162static void andn_c(asap_state *);
163static void andn_c0(asap_state *);
164static void or_(asap_state *);
165static void or_c(asap_state *);
166static void or_c0(asap_state *);
167static void orn(asap_state *);
168static void orn_c(asap_state *);
169static void orn_c0(asap_state *);
170static void ld(asap_state *);
171static void ld_0(asap_state *);
172static void ld_c(asap_state *);
173static void ld_c0(asap_state *);
174static void ldh(asap_state *);
175static void ldh_0(asap_state *);
176static void ldh_c(asap_state *);
177static void ldh_c0(asap_state *);
178static void lduh(asap_state *);
179static void lduh_0(asap_state *);
180static void lduh_c(asap_state *);
181static void lduh_c0(asap_state *);
182static void sth(asap_state *);
183static void sth_0(asap_state *);
184static void sth_c(asap_state *);
185static void sth_c0(asap_state *);
186static void st(asap_state *);
187static void st_0(asap_state *);
188static void st_c(asap_state *);
189static void st_c0(asap_state *);
190static void ldb(asap_state *);
191static void ldb_0(asap_state *);
192static void ldb_c(asap_state *);
193static void ldb_c0(asap_state *);
194static void ldub(asap_state *);
195static void ldub_0(asap_state *);
196static void ldub_c(asap_state *);
197static void ldub_c0(asap_state *);
198static void stb(asap_state *);
199static void stb_0(asap_state *);
200static void stb_c(asap_state *);
201static void stb_c0(asap_state *);
202static void ashr(asap_state *);
203static void ashr_c(asap_state *);
204static void ashr_c0(asap_state *);
205static void lshr(asap_state *);
206static void lshr_c(asap_state *);
207static void lshr_c0(asap_state *);
208static void ashl(asap_state *);
209static void ashl_c(asap_state *);
210static void ashl_c0(asap_state *);
211static void rotl(asap_state *);
212static void rotl_c(asap_state *);
213static void rotl_c0(asap_state *);
214static void getps(asap_state *);
215static void putps(asap_state *);
216static void jsr(asap_state *);
217static void jsr_0(asap_state *);
218static void jsr_c(asap_state *);
219static void jsr_c0(asap_state *);
220static void trapf(asap_state *);
177device_config *asap_device_config::static_alloc_device_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock)
178{
179   return global_alloc(asap_device_config(mconfig, tag, owner, clock));
180}
221181
222typedef void (*asap_ophandler)(asap_state *);
223182
224static const asap_ophandler opcodetable[32][4] =
183//-------------------------------------------------
184//  alloc_device - allocate a new device object
185//-------------------------------------------------
186
187device_t *asap_device_config::alloc_device(running_machine &machine) const
225188{
226   {   trap0,      trap0,      trap0,      trap0      },
227   {   NULL,      NULL,      NULL,      NULL      },
228   {   bsr,      bsr_0,      bsr,      bsr_0      },
229   {   lea,      noop,      lea_c,      lea_c0      },
230   {   leah,      noop,      leah_c,      leah_c0      },
231   {   subr,      noop,      subr_c,      subr_c0      },
232   {   xor_,      noop,      xor_c,      xor_c0      },
233   {   xorn,      noop,      xorn_c,      xorn_c0      },
234   {   add,      noop,      add_c,      add_c0      },
235   {   sub,      noop,      sub_c,      sub_c0      },
236   {   addc,      noop,      addc_c,      addc_c0      },
237   {   subc,      noop,      subc_c,      subc_c0      },
238   {   and_,      noop,      and_c,      and_c0      },
239   {   andn,      noop,      andn_c,      andn_c0      },
240   {   or_,      noop,      or_c,      or_c0      },
241   {   orn,      noop,      orn_c,      orn_c0      },
242   {   ld,         ld_0,      ld_c,      ld_c0      },
243   {   ldh,      ldh_0,      ldh_c,      ldh_c0      },
244   {   lduh,      lduh_0,      lduh_c,      lduh_c0      },
245   {   sth,      sth_0,      sth_c,      sth_c0      },
246   {   st,         st_0,      st_c,      st_c0      },
247   {   ldb,      ldb_0,      ldb_c,      ldb_c0      },
248   {   ldub,      ldub_0,      ldub_c,      ldub_c0      },
249   {   stb,      stb_0,      stb_c,      stb_c0      },
250   {   ashr,      noop,      ashr_c,      ashr_c0      },
251   {   lshr,      noop,      lshr_c,      lshr_c0      },
252   {   ashl,      noop,      ashl_c,      ashl_c0      },
253   {   rotl,      noop,      rotl_c,      rotl_c0      },
254   {   getps,      noop,      getps,      noop      },
255   {   putps,      putps,      putps,      putps      },
256   {   jsr,      jsr_0,      jsr_c,      jsr_c0      },
257   {   trapf,      trapf,      trapf,      trapf      }
258};
189   return auto_alloc(&machine, asap_device(machine, *this));
190}
259191
260static void (*const conditiontable[16])(asap_state *) =
192//-------------------------------------------------
193//  execute_min_cycles - return minimum number of
194//  cycles it takes for one instruction to execute
195//-------------------------------------------------
196
197UINT32 asap_device_config::execute_min_cycles() const
261198{
262   bsp, bmz, bgt, ble, bge, blt, bhi, bls,
263   bcc, bcs, bpl, bmi, bne, beq, bvc, bvs
264};
199   return 1;
200}
265201
266202
203//-------------------------------------------------
204//  execute_max_cycles - return maximum number of
205//  cycles it takes for one instruction to execute
206//-------------------------------------------------
267207
268/***************************************************************************
269    STATE ACCESSORS
270***************************************************************************/
208UINT32 asap_device_config::execute_max_cycles() const
209{
210   return 2;
211}
271212
272INLINE asap_state *get_safe_token(running_device *device)
213
214//-------------------------------------------------
215//  execute_input_lines - return the number of
216//  input/interrupt lines
217//-------------------------------------------------
218
219UINT32 asap_device_config::execute_input_lines() const
273220{
274   assert(device != NULL);
275   assert(device->type() == ASAP);
276   return (asap_state *)downcast<legacy_cpu_device *>(device)->token();
221   return 1;
277222}
278223
279224
225//-------------------------------------------------
226//  memory_space_config - return the configuration
227//  of the specified address space, or NULL if
228//  the space doesn't exist
229//-------------------------------------------------
280230
281/***************************************************************************
282    MEMORY ACCESSORS
283***************************************************************************/
231const address_space_config *asap_device_config::memory_space_config(int spacenum) const
232{
233   return (spacenum == AS_PROGRAM) ? &m_program_config : NULL;
234}
284235
285#define ROPCODE(A,pc)   (A)->direct->read_decrypted_dword(pc)
286236
237//-------------------------------------------------
238//  disasm_min_opcode_bytes - return the length
239//  of the shortest instruction, in bytes
240//-------------------------------------------------
287241
288INLINE UINT8 READBYTE(asap_state *asap, offs_t address)
242UINT32 asap_device_config::disasm_min_opcode_bytes() const
289243{
290   /* no alignment issues with bytes */
291   return asap->program->read_byte(address);
244   return 4;
292245}
293246
294INLINE UINT16 READWORD(asap_state *asap, offs_t address)
247
248//-------------------------------------------------
249//  disasm_max_opcode_bytes - return the length
250//  of the longest instruction, in bytes
251//-------------------------------------------------
252
253UINT32 asap_device_config::disasm_max_opcode_bytes() const
295254{
296   /* aligned reads are easy */
297   if (!(address & 1))
298      return asap->program->read_word(address);
255   return 12;
256}
299257
300   /* misaligned reads are tricky */
301   return asap->program->read_dword(address & ~3) >> (address & 3);
258
259
260//**************************************************************************
261//  DEVICE INTERFACE
262//**************************************************************************
263
264//-------------------------------------------------
265//  asap_device - constructor
266//-------------------------------------------------
267
268asap_device::asap_device(running_machine &_machine, const asap_device_config &config)
269   : cpu_device(_machine, config),
270     m_pc(0),
271     m_pflag(0),
272     m_iflag(0),
273     m_cflag(0),
274     m_vflag(0),
275     m_znflag(0),
276     m_flagsio(0),
277     m_op(0),
278     m_ppc(0),
279     m_nextpc(0),
280     m_irq_state(0),
281     m_icount(0),
282     m_program(NULL),
283     m_direct(NULL)
284{
285   // initialize the src2val table to contain immediates for low values
286   for (int i = 0; i < REGBASE; i++)
287      m_src2val[i] = i;
288
289   // build the opcode table
290   for (int op = 0; op < 32; op++)
291      for (int dst = 0; dst < 32; dst++)
292         for (int cond = 0; cond < 2; cond++)
293            if (op == 1)
294               m_opcode[(op << 6) + (dst << 1) + cond] = s_conditiontable[dst & 15];
295            else if (cond && dst == 0)
296               m_opcode[(op << 6) + (dst << 1) + cond] = s_opcodetable[op][3];
297            else if (cond)
298               m_opcode[(op << 6) + (dst << 1) + cond] = s_opcodetable[op][2];
299            else if (dst == 0)
300               m_opcode[(op << 6) + (dst << 1) + cond] = s_opcodetable[op][1];
301            else
302               m_opcode[(op << 6) + (dst << 1) + cond] = s_opcodetable[op][0];
302303}
303304
304INLINE UINT32 READLONG(asap_state *asap, offs_t address)
305
306//-------------------------------------------------
307//  device_start - start up the device
308//-------------------------------------------------
309
310void asap_device::device_start()
305311{
306   /* aligned reads are easy */
307   if (!(address & 3))
308      return asap->program->read_dword(address);
312   // get our address spaces
313   m_program = space(AS_PROGRAM);
314   m_direct = &m_program->direct();
309315
310   /* misaligned reads are tricky */
311   return asap->program->read_dword(address & ~3) >> (address & 3);
316   // register our state for the debugger
317   astring tempstr;
318   state_add(STATE_GENPC,     "GENPC",     m_pc).noshow();
319   state_add(STATE_GENPCBASE, "GENPCBASE", m_ppc).noshow();
320   state_add(STATE_GENSP,     "GENSP",     m_src2val[REGBASE + 31]).noshow();
321   state_add(STATE_GENFLAGS,  "GENFLAGS",  m_flagsio).callimport().callexport().formatstr("%6s").noshow();
322   state_add(ASAP_PC,         "PC",        m_pc);
323   state_add(ASAP_PS,         "PS",        m_flagsio).callimport().callexport();
324   for (int regnum = 0; regnum < 32; regnum++)
325      state_add(ASAP_R0 + regnum, tempstr.format("R%d", regnum), m_src2val[REGBASE + regnum]);
326
327   // register our state for saving
328   state_save_register_device_item(this, 0, m_pc);
329   state_save_register_device_item(this, 0, m_pflag);
330   state_save_register_device_item(this, 0, m_iflag);
331   state_save_register_device_item(this, 0, m_cflag);
332   state_save_register_device_item(this, 0, m_vflag);
333   state_save_register_device_item(this, 0, m_znflag);
334   state_save_register_device_item(this, 0, m_op);
335   state_save_register_device_item(this, 0, m_ppc);
336   state_save_register_device_item(this, 0, m_nextpc);
337   state_save_register_device_item(this, 0, m_irq_state);
338   
339   // set our instruction counter
340   m_icountptr = &m_icount;
312341}
313342
314INLINE void WRITEBYTE(asap_state *asap, offs_t address, UINT8 data)
343
344//-------------------------------------------------
345//  device_reset - reset the device
346//-------------------------------------------------
347
348void asap_device::device_reset()
315349{
316   /* no alignment issues with bytes */
317   asap->program->write_byte(address, data);
350   // initialize the state
351   m_src2val[REGBASE + 0] = 0;
352   m_pc = 0;
353   m_iflag = 0;
354
355   m_ppc = 0;
356   m_nextpc = ~0;
357   m_irq_state = 0;
318358}
319359
320INLINE void WRITEWORD(asap_state *asap, offs_t address, UINT16 data)
360
361//-------------------------------------------------
362//  state_import - import state into the device,
363//  after it has been set
364//-------------------------------------------------
365
366void asap_device::state_import(const device_state_entry &entry)
321367{
322   /* aligned writes are easy */
323   if (!(address & 1))
368   switch (entry.index())
324369   {
325      asap->program->write_word(address, data);
326      return;
370      case STATE_GENFLAGS:
371      case ASAP_PS:
372         SET_FLAGS(m_flagsio);
373         break;
327374   }
375}
328376
329   /* misaligned writes are tricky */
330   if (!(address & 2))
377
378//-------------------------------------------------
379//  state_export - export state from the device,
380//  to a known location where it can be read
381//-------------------------------------------------
382
383void asap_device::state_export(const device_state_entry &entry)
384{
385   switch (entry.index())
331386   {
332      asap->program->write_byte(address + 1, data);
333      asap->program->write_byte(address + 2, data >> 8);
387      case STATE_GENFLAGS:
388      case ASAP_PS:
389         m_flagsio = GET_FLAGS();
390         break;
334391   }
335   else
336      asap->program->write_byte(address + 1, data);
337392}
338393
339INLINE void WRITELONG(asap_state *asap, offs_t address, UINT32 data)
394
395//-------------------------------------------------
396//  state_string_export - export state as a string
397//  for the debugger
398//-------------------------------------------------
399
400void asap_device::state_string_export(const device_state_entry &entry, astring &string)
340401{
341   /* aligned writes are easy */
342   if (!(address & 3))
402   switch (entry.index())
343403   {
344      asap->program->write_dword(address, data);
345      return;
346   }
347
348   /* misaligned writes are tricky */
349   switch (address & 3)
350   {
351      case 1:
352         asap->program->write_byte(address, data);
353         asap->program->write_word(address + 1, data >> 8);
404      case STATE_GENFLAGS:
405         string.printf("%c%c%c%c%c%c",
406                     m_pflag ? 'P' : '.',
407                     m_iflag ? 'I' : '.',
408                     ((INT32)m_znflag < 0) ? 'N' : '.',
409                     (m_znflag == 0) ? 'Z' : '.',
410                     ((m_vflag >> 30) & PS_VFLAG) ? 'V' : '.',
411                     m_cflag ? 'C' : '.');
354412         break;
355      case 2:
356         asap->program->write_word(address, data);
357         break;
358      case 3:
359         asap->program->write_byte(address, data);
360         break;
361413   }
362414}
363415
364416
417//-------------------------------------------------
418//  disasm_disassemble - call the disassembly
419//  helper function
420//-------------------------------------------------
365421
366/***************************************************************************
367    EXCEPTION HANDLING
368***************************************************************************/
369
370INLINE void generate_exception(asap_state *asap, int exception)
422offs_t asap_device::disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options)
371423{
372   asap->pflag = asap->iflag;
373   asap->iflag = 0;
424   extern offs_t asap_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram);
425   return asap_disassemble(buffer, pc, oprom, opram);
426}
374427
375   asap->src2val[REGBASE + 30] = asap->pc;
376   asap->src2val[REGBASE + 31] = (asap->nextpc == ~0) ? asap->pc + 4 : asap->nextpc;
377428
378   asap->pc = 0x40 * exception;
379   asap->nextpc = ~0;
380429
381   asap->icount--;
382}
430//**************************************************************************
431//  INLINE HELPERS
432//**************************************************************************
383433
434//-------------------------------------------------
435//  readop - read an opcode at the given address
436//-------------------------------------------------
384437
438inline UINT32 asap_device::readop(offs_t pc)
439{
440   return m_direct->read_decrypted_dword(pc);
441}
385442
386/***************************************************************************
387    IRQ HANDLING
388***************************************************************************/
389443
390INLINE void check_irqs(asap_state *asap)
444//-------------------------------------------------
445//  readbyte - read a byte at the given address
446//-------------------------------------------------
447
448inline UINT8 asap_device::readbyte(offs_t address)
391449{
392   if (asap->irq_state && asap->iflag)
393   {
394      generate_exception(asap, EXCEPTION_INTERRUPT);
395      if (asap->irq_callback != NULL)
396         (*asap->irq_callback)(asap->device, ASAP_IRQ0);
397   }
450   // no alignment issues with bytes
451   return m_program->read_byte(address);
398452}
399453
400454
401static void set_irq_line(asap_state *asap, int irqline, int state)
455//-------------------------------------------------
456//  readword - read a word at the given address
457//-------------------------------------------------
458
459inline UINT16 asap_device::readword(offs_t address)
402460{
403   asap->irq_state = (state != CLEAR_LINE);
461   // aligned reads are easy
462   if (!(address & 1))
463      return m_program->read_word(address);
464
465   // misaligned reads are tricky
466   return m_program->read_dword(address & ~3) >> (address & 3);
404467}
405468
406469
470//-------------------------------------------------
471//  readlong - read a long at the given address
472//-------------------------------------------------
407473
408/***************************************************************************
409    INITIALIZATION AND SHUTDOWN
410***************************************************************************/
474inline UINT32 asap_device::readlong(offs_t address)
475{
476   // aligned reads are easy
477   if (!(address & 3))
478      return m_program->read_dword(address);
411479
412static void init_tables(running_machine *machine)
480   // misaligned reads are tricky
481   return m_program->read_dword(address & ~3) >> (address & 3);
482}
483
484
485//-------------------------------------------------
486//  writebyte - write a byte at the given address
487//-------------------------------------------------
488
489inline void asap_device::writebyte(offs_t address, UINT8 data)
413490{
414   /* allocate opcode table */
415   if (!opcode)
416      opcode = auto_alloc_array(machine, asap_ophandler, 32 * 32 * 2);
491   // no alignment issues with bytes
492   m_program->write_byte(address, data);
493}
417494
418   /* fill opcode table */
419   if (opcode)
495
496//-------------------------------------------------
497//  writeword - write a word at the given address
498//-------------------------------------------------
499
500inline void asap_device::writeword(offs_t address, UINT16 data)
501{
502   // aligned writes are easy
503   if (!(address & 1))
420504   {
421      int op, dst, cond;
505      m_program->write_word(address, data);
506      return;
507   }
422508
423      for (op = 0; op < 32; op++)
424         for (dst = 0; dst < 32; dst++)
425            for (cond = 0; cond < 2; cond++)
426               if (op == 1)
427                  opcode[(op << 6) + (dst << 1) + cond] = conditiontable[dst & 15];
428               else if (cond && dst == 0)
429                  opcode[(op << 6) + (dst << 1) + cond] = opcodetable[op][3];
430               else if (cond)
431                  opcode[(op << 6) + (dst << 1) + cond] = opcodetable[op][2];
432               else if (dst == 0)
433                  opcode[(op << 6) + (dst << 1) + cond] = opcodetable[op][1];
434               else
435                  opcode[(op << 6) + (dst << 1) + cond] = opcodetable[op][0];
509   // misaligned writes are tricky
510   if (!(address & 2))
511   {
512      m_program->write_byte(address + 1, data);
513      m_program->write_byte(address + 2, data >> 8);
436514   }
515   else
516      m_program->write_byte(address + 1, data);
437517}
438518
439static CPU_INIT( asap )
440{
441   asap_state *asap = get_safe_token(device);
442   int i;
443519
444   init_tables(device->machine);
445   for (i = 0; i < REGBASE; i++)
446      asap->src2val[i] = i;
447   asap->irq_callback = irqcallback;
448   asap->device = device;
449   asap->program = device->space(AS_PROGRAM);
450   asap->direct = &asap->program->direct();
520//-------------------------------------------------
521//  writelong - write a long at the given address
522//-------------------------------------------------
451523
524inline void asap_device::writelong(offs_t address, UINT32 data)
525{
526   // aligned writes are easy
527   if (!(address & 3))
528   {
529      m_program->write_dword(address, data);
530      return;
531   }
452532
453   state_save_register_device_item(device, 0, asap->pc);
454   state_save_register_device_item(device, 0, asap->pflag);
455   state_save_register_device_item(device, 0, asap->iflag);
456   state_save_register_device_item(device, 0, asap->cflag);
457   state_save_register_device_item(device, 0, asap->vflag);
458   state_save_register_device_item(device, 0, asap->znflag);
459   state_save_register_device_item(device, 0, asap->op);
460   state_save_register_device_item(device, 0, asap->ppc);
461   state_save_register_device_item(device, 0, asap->nextpc);
462   state_save_register_device_item(device, 0, asap->irq_state);
533   // misaligned writes are tricky
534   switch (address & 3)
535   {
536      case 1:
537         m_program->write_byte(address, data);
538         m_program->write_word(address + 1, data >> 8);
539         break;
540      case 2:
541         m_program->write_word(address, data);
542         break;
543      case 3:
544         m_program->write_byte(address, data);
545         break;
546   }
463547}
464548
465static CPU_RESET( asap )
549
550//-------------------------------------------------
551//  generate_exception - generate an exception of
552//  the requested type
553//-------------------------------------------------
554
555inline void asap_device::generate_exception(int exception)
466556{
467   asap_state *asap = get_safe_token(device);
557   m_pflag = m_iflag;
558   m_iflag = 0;
468559
469   /* initialize the state */
470   asap->src2val[REGBASE + 0] = 0;
471   asap->pc = 0;
472   asap->iflag = 0;
560   m_src2val[REGBASE + 30] = m_pc;
561   m_src2val[REGBASE + 31] = (m_nextpc == ~0) ? m_pc + 4 : m_nextpc;
473562
474   asap->ppc = 0;
475   asap->nextpc = ~0;
476   asap->irq_state = 0;
477   asap->irq_callback = NULL;
563   m_pc = 0x40 * exception;
564   m_nextpc = ~0;
565
566   m_icount--;
478567}
479568
480569
481static CPU_EXIT( asap )
570//-------------------------------------------------
571//  check_irqs - check for pending IRQs
572//-------------------------------------------------
573
574inline void asap_device::check_irqs()
482575{
483   opcode = NULL;
576   if (m_irq_state && m_iflag)
577   {
578      generate_exception(EXCEPTION_INTERRUPT);
579      standard_irq_callback(ASAP_IRQ0);
580   }
484581}
485582
486583
487584
488/***************************************************************************
489    CORE EXECUTION LOOP
490***************************************************************************/
585//**************************************************************************
586//  CORE EXECUTION
587//**************************************************************************
491588
492INLINE void fetch_instruction(asap_state *asap)
589inline void asap_device::fetch_instruction()
493590{
494   /* debugging */
495   asap->ppc = asap->pc;
591   // debugging
592   m_ppc = m_pc;
496593
497   /* instruction fetch */
498   asap->op.d = ROPCODE(asap, asap->pc);
499   asap->pc += 4;
594   // instruction fetch
595   m_op = readop(m_pc);
596   m_pc += 4;
500597}
501598
502INLINE void fetch_instruction_debug(asap_state *asap)
599inline void asap_device::fetch_instruction_debug()
503600{
504   /* debugging */
505   asap->ppc = asap->pc;
506   debugger_instruction_hook(asap->device, asap->pc);
601   // debugging
602   m_ppc = m_pc;
603   debugger_instruction_hook(this, m_pc);
507604
508   /* instruction fetch */
509   asap->op.d = ROPCODE(asap, asap->pc);
510   asap->pc += 4;
605   // instruction fetch
606   m_op = readop(m_pc);
607   m_pc += 4;
511608}
512609
513INLINE void execute_instruction(asap_state *asap)
610inline void asap_device::execute_instruction()
514611{
515   /* parse the instruction */
516   (*opcode[asap->op.d >> 21])(asap);
612   // parse the instruction
613   (this->*m_opcode[m_op >> 21])();
517614}
518615
519static CPU_EXECUTE( asap )
616
617void asap_device::execute_set_input(int inputnum, int state)
520618{
521   asap_state *asap = get_safe_token(device);
619   m_irq_state = (state != CLEAR_LINE);
620}
522621
523   /* check for IRQs */
524   check_irqs(asap);
525622
526   /* core execution loop */
527   if ((device->machine->debug_flags & DEBUG_FLAG_ENABLED) == 0)
623void asap_device::execute_run()
624{
625   // check for IRQs
626   check_irqs();
627
628   // core execution loop
629   if ((device_t::m_machine.debug_flags & DEBUG_FLAG_ENABLED) == 0)
528630   {
529631      do
530632      {
531         /* fetch and execute the next instruction */
532         fetch_instruction(asap);
533         execute_instruction(asap);
633         // fetch and execute the next instruction
634         fetch_instruction();
635         execute_instruction();
534636
535         /* fetch and execute the next instruction */
536         fetch_instruction(asap);
537         execute_instruction(asap);
637         // fetch and execute the next instruction
638         fetch_instruction();
639         execute_instruction();
538640
539         /* fetch and execute the next instruction */
540         fetch_instruction(asap);
541         execute_instruction(asap);
641         // fetch and execute the next instruction
642         fetch_instruction();
643         execute_instruction();
542644
543         /* fetch and execute the next instruction */
544         fetch_instruction(asap);
545         execute_instruction(asap);
645         // fetch and execute the next instruction
646         fetch_instruction();
647         execute_instruction();
546648
547         asap->icount -= 4;
649         m_icount -= 4;
548650
549      } while (asap->icount > 0);
651      } while (m_icount > 0);
550652   }
551653   else
552654   {
553655      do
554656      {
555         /* fetch and execute the next instruction */
556         fetch_instruction_debug(asap);
557         execute_instruction(asap);
657         // fetch and execute the next instruction
658         fetch_instruction_debug();
659         execute_instruction();
558660
559         /* fetch and execute the next instruction */
560         fetch_instruction_debug(asap);
561         execute_instruction(asap);
661         // fetch and execute the next instruction
662         fetch_instruction_debug();
663         execute_instruction();
562664
563         /* fetch and execute the next instruction */
564         fetch_instruction_debug(asap);
565         execute_instruction(asap);
665         // fetch and execute the next instruction
666         fetch_instruction_debug();
667         execute_instruction();
566668
567         /* fetch and execute the next instruction */
568         fetch_instruction_debug(asap);
569         execute_instruction(asap);
669         // fetch and execute the next instruction
670         fetch_instruction_debug();
671         execute_instruction();
570672
571         asap->icount -= 4;
673         m_icount -= 4;
572674
573      } while (asap->icount > 0);
675      } while (m_icount > 0);
574676   }
575677}
576678
577679
578680
579/***************************************************************************
580    DISASSEMBLY HOOK
581***************************************************************************/
681//**************************************************************************
682//  OPCODE IMPLEMENTATIONS
683//**************************************************************************
582684
583extern CPU_DISASSEMBLE( asap );
584
585
586
587/***************************************************************************
588    HELPER MACROS
589***************************************************************************/
590
591#define OPCODE(A)   ((A)->op.d >> 27)
592#define DSTREG(A)   (((A)->op.d >> 22) & 31)
593#define DSTVAL(A)   (A)->src2val[REGBASE + DSTREG(A)]
594#define SRC1REG(A)   (((A)->op.d >> 16) & 31)
595#define SRC1VAL(A)   (A)->src2val[REGBASE + SRC1REG(A)]
596#define SRC2VAL(A)   (A)->src2val[(A)->op.w.l]
597
598
599
600/***************************************************************************
601    OPCODES
602***************************************************************************/
603
604static void noop(asap_state *asap)
685void asap_device::noop()
605686{
606687}
607688
608689/**************************** TRAP 0 ******************************/
609690
610static void trap0(asap_state *asap)
691void asap_device::trap0()
611692{
612   generate_exception(asap, EXCEPTION_TRAP0);
693   generate_exception(EXCEPTION_TRAP0);
613694}
614695
615696/**************************** Bcc ******************************/
616697
617static void bsp(asap_state *asap)
698void asap_device::bsp()
618699{
619   if ((INT32)asap->znflag > 0)
700   if ((INT32)m_znflag > 0)
620701   {
621      asap->nextpc = asap->ppc + ((INT32)(asap->op.d << 10) >> 8);
702      m_nextpc = m_ppc + ((INT32)(m_op << 10) >> 8);
622703
623      fetch_instruction(asap);
624      asap->pc = asap->nextpc;
625      asap->nextpc = ~0;
704      fetch_instruction();
705      m_pc = m_nextpc;
706      m_nextpc = ~0;
626707
627      execute_instruction(asap);
628      asap->icount--;
708      execute_instruction();
709      m_icount--;
629710   }
630711}
631712
632static void bmz(asap_state *asap)
713void asap_device::bmz()
633714{
634   if ((INT32)asap->znflag <= 0)
715   if ((INT32)m_znflag <= 0)
635716   {
636      asap->nextpc = asap->ppc + ((INT32)(asap->op.d << 10) >> 8);
717      m_nextpc = m_ppc + ((INT32)(m_op << 10) >> 8);
637718
638      fetch_instruction(asap);
639      asap->pc = asap->nextpc;
640      asap->nextpc = ~0;
719      fetch_instruction();
720      m_pc = m_nextpc;
721      m_nextpc = ~0;
641722
642      execute_instruction(asap);
643      asap->icount--;
723      execute_instruction();
724      m_icount--;
644725   }
645726}
646727
647static void bgt(asap_state *asap)
728void asap_device::bgt()
648729{
649   if (asap->znflag != 0 && (INT32)(asap->znflag ^ asap->vflag) >= 0)
730   if (m_znflag != 0 && (INT32)(m_znflag ^ m_vflag) >= 0)
650731   {
651      asap->nextpc = asap->ppc + ((INT32)(asap->op.d << 10) >> 8);
732      m_nextpc = m_ppc + ((INT32)(m_op << 10) >> 8);
652733
653      fetch_instruction(asap);
654      asap->pc = asap->nextpc;
655      asap->nextpc = ~0;
734      fetch_instruction();
735      m_pc = m_nextpc;
736      m_nextpc = ~0;
656737
657      execute_instruction(asap);
658      asap->icount--;
738      execute_instruction();
739      m_icount--;
659740   }
660741}
661742
662static void ble(asap_state *asap)
743void asap_device::ble()
663744{
664   if (asap->znflag == 0 || (INT32)(asap->znflag ^ asap->vflag) < 0)
745   if (m_znflag == 0 || (INT32)(m_znflag ^ m_vflag) < 0)
665746   {
666      asap->nextpc = asap->ppc + ((INT32)(asap->op.d << 10) >> 8);
747      m_nextpc = m_ppc + ((INT32)(m_op << 10) >> 8);
667748
668      fetch_instruction(asap);
669      asap->pc = asap->nextpc;
670      asap->nextpc = ~0;
749      fetch_instruction();
750      m_pc = m_nextpc;
751      m_nextpc = ~0;
671752
672      execute_instruction(asap);
673      asap->icount--;
753      execute_instruction();
754      m_icount--;
674755   }
675756}
676757
677static void bge(asap_state *asap)
758void asap_device::bge()
678759{
679   if ((INT32)(asap->znflag ^ asap->vflag) >= 0)
760   if ((INT32)(m_znflag ^ m_vflag) >= 0)
680761   {
681      asap->nextpc = asap->ppc + ((INT32)(asap->op.d << 10) >> 8);
762      m_nextpc = m_ppc + ((INT32)(m_op << 10) >> 8);
682763
683      fetch_instruction(asap);
684      asap->pc = asap->nextpc;
685      asap->nextpc = ~0;
764      fetch_instruction();
765      m_pc = m_nextpc;
766      m_nextpc = ~0;
686767
687      execute_instruction(asap);
688      asap->icount--;
768      execute_instruction();
769      m_icount--;
689770   }
690771}
691772
692static void blt(asap_state *asap)
773void asap_device::blt()
693774{
694   if ((INT32)(asap->znflag ^ asap->vflag) < 0)
775   if ((INT32)(m_znflag ^ m_vflag) < 0)
695776   {
696      asap->nextpc = asap->ppc + ((INT32)(asap->op.d << 10) >> 8);
777      m_nextpc = m_ppc + ((INT32)(m_op << 10) >> 8);
697778
698      fetch_instruction(asap);
699      asap->pc = asap->nextpc;
700      asap->nextpc = ~0;
779      fetch_instruction();
780      m_pc = m_nextpc;
781      m_nextpc = ~0;
701782
702      execute_instruction(asap);
703      asap->icount--;
783      execute_instruction();
784      m_icount--;
704785   }
705786}
706787
707static void bhi(asap_state *asap)
788void asap_device::bhi()
708789{
709   if (asap->znflag != 0 && asap->cflag)
790   if (m_znflag != 0 && m_cflag)
710791   {
711      asap->nextpc = asap->ppc + ((INT32)(asap->op.d << 10) >> 8);
792      m_nextpc = m_ppc + ((INT32)(m_op << 10) >> 8);
712793
713      fetch_instruction(asap);
714      asap->pc = asap->nextpc;
715      asap->nextpc = ~0;
794      fetch_instruction();
795      m_pc = m_nextpc;
796      m_nextpc = ~0;
716797
717      execute_instruction(asap);
718      asap->icount--;
798      execute_instruction();
799      m_icount--;
719800   }
720801}
721802
722static void bls(asap_state *asap)
803void asap_device::bls()
723804{
724   if (asap->znflag == 0 || !asap->cflag)
805   if (m_znflag == 0 || !m_cflag)
725806   {
726      asap->nextpc = asap->ppc + ((INT32)(asap->op.d << 10) >> 8);
807      m_nextpc = m_ppc + ((INT32)(m_op << 10) >> 8);
727808
728      fetch_instruction(asap);
729      asap->pc = asap->nextpc;
730      asap->nextpc = ~0;
809      fetch_instruction();
810      m_pc = m_nextpc;
811      m_nextpc = ~0;
731812
732      execute_instruction(asap);
733      asap->icount--;
813      execute_instruction();
814      m_icount--;
734815   }
735816}
736817
737static void bcc(asap_state *asap)
818void asap_device::bcc()
738819{
739   if (!asap->cflag)
820   if (!m_cflag)
740821   {
741      asap->nextpc = asap->ppc + ((INT32)(asap->op.d << 10) >> 8);
822      m_nextpc = m_ppc + ((INT32)(m_op << 10) >> 8);
742823
743      fetch_instruction(asap);
744      asap->pc = asap->nextpc;
745      asap->nextpc = ~0;
824      fetch_instruction();
825      m_pc = m_nextpc;
826      m_nextpc = ~0;
746827
747      execute_instruction(asap);
748      asap->icount--;
828      execute_instruction();
829      m_icount--;
749830   }
750831}
751832
752static void bcs(asap_state *asap)
833void asap_device::bcs()
753834{
754   if (asap->cflag)
835   if (m_cflag)
755836   {
756      asap->nextpc = asap->ppc + ((INT32)(asap->op.d << 10) >> 8);
837      m_nextpc = m_ppc + ((INT32)(m_op << 10) >> 8);
757838
758      fetch_instruction(asap);
759      asap->pc = asap->nextpc;
760      asap->nextpc = ~0;
839      fetch_instruction();
840      m_pc = m_nextpc;
841      m_nextpc = ~0;
761842
762      execute_instruction(asap);
763      asap->icount--;
843      execute_instruction();
844      m_icount--;
764845   }
765846}
766847
767static void bpl(asap_state *asap)
848void asap_device::bpl()
768849{
769   if ((INT32)asap->znflag >= 0)
850   if ((INT32)m_znflag >= 0)
770851   {
771      asap->nextpc = asap->ppc + ((INT32)(asap->op.d << 10) >> 8);
852      m_nextpc = m_ppc + ((INT32)(m_op << 10) >> 8);
772853
773      fetch_instruction(asap);
774      asap->pc = asap->nextpc;
775      asap->nextpc = ~0;
854      fetch_instruction();
855      m_pc = m_nextpc;
856      m_nextpc = ~0;
776857
777      execute_instruction(asap);
778      asap->icount--;
858      execute_instruction();
859      m_icount--;
779860   }
780861}
781862
782static void bmi(asap_state *asap)
863void asap_device::bmi()
783864{
784   if ((INT32)asap->znflag < 0)
865   if ((INT32)m_znflag < 0)
785866   {
786      asap->nextpc = asap->ppc + ((INT32)(asap->op.d << 10) >> 8);
867      m_nextpc = m_ppc + ((INT32)(m_op << 10) >> 8);
787868
788      fetch_instruction(asap);
789      asap->pc = asap->nextpc;
790      asap->nextpc = ~0;
869      fetch_instruction();
870      m_pc = m_nextpc;
871      m_nextpc = ~0;
791872
792      execute_instruction(asap);
793      asap->icount--;
873      execute_instruction();
874      m_icount--;
794875   }
795876}
796877
797static void bne(asap_state *asap)
878void asap_device::bne()
798879{
799   if (asap->znflag != 0)
880   if (m_znflag != 0)
800881   {
801      asap->nextpc = asap->ppc + ((INT32)(asap->op.d << 10) >> 8);
882      m_nextpc = m_ppc + ((INT32)(m_op << 10) >> 8);
802883
803      fetch_instruction(asap);
804      asap->pc = asap->nextpc;
805      asap->nextpc = ~0;
884      fetch_instruction();
885      m_pc = m_nextpc;
886      m_nextpc = ~0;
806887
807      execute_instruction(asap);
808      asap->icount--;
888      execute_instruction();
889      m_icount--;
809890   }
810891}
811892
812static void beq(asap_state *asap)
893void asap_device::beq()
813894{
814   if (asap->znflag == 0)
895   if (m_znflag == 0)
815896   {
816      asap->nextpc = asap->ppc + ((INT32)(asap->op.d << 10) >> 8);
897      m_nextpc = m_ppc + ((INT32)(m_op << 10) >> 8);
817898
818      fetch_instruction(asap);
819      asap->pc = asap->nextpc;
820      asap->nextpc = ~0;
899      fetch_instruction();
900      m_pc = m_nextpc;
901      m_nextpc = ~0;
821902
822      execute_instruction(asap);
823      asap->icount--;
903      execute_instruction();
904      m_icount--;
824905   }
825906}
826907
827static void bvc(asap_state *asap)
908void asap_device::bvc()
828909{
829   if ((INT32)asap->vflag >= 0)
910   if ((INT32)m_vflag >= 0)
830911   {
831      asap->nextpc = asap->ppc + ((INT32)(asap->op.d << 10) >> 8);
912      m_nextpc = m_ppc + ((INT32)(m_op << 10) >> 8);
832913
833      fetch_instruction(asap);
834      asap->pc = asap->nextpc;
835      asap->nextpc = ~0;
914      fetch_instruction();
915      m_pc = m_nextpc;
916      m_nextpc = ~0;
836917
837      execute_instruction(asap);
838      asap->icount--;
918      execute_instruction();
919      m_icount--;
839920   }
840921}
841922
842static void bvs(asap_state *asap)
923void asap_device::bvs()
843924{
844   if ((INT32)asap->vflag < 0)
925   if ((INT32)m_vflag < 0)
845926   {
846      asap->nextpc = asap->ppc + ((INT32)(asap->op.d << 10) >> 8);
927      m_nextpc = m_ppc + ((INT32)(m_op << 10) >> 8);
847928
848      fetch_instruction(asap);
849      asap->pc = asap->nextpc;
850      asap->nextpc = ~0;
929      fetch_instruction();
930      m_pc = m_nextpc;
931      m_nextpc = ~0;
851932
852      execute_instruction(asap);
853      asap->icount--;
933      execute_instruction();
934      m_icount--;
854935   }
855936}
856937
857938/**************************** BSR ******************************/
858939
859static void bsr(asap_state *asap)
940void asap_device::bsr()
860941{
861   DSTVAL(asap) = asap->pc + 4;
862   asap->nextpc = asap->ppc + ((INT32)(asap->op.d << 10) >> 8);
942   DSTVAL = m_pc + 4;
943   m_nextpc = m_ppc + ((INT32)(m_op << 10) >> 8);
863944
864   fetch_instruction(asap);
865   asap->pc = asap->nextpc;
866   asap->nextpc = ~0;
945   fetch_instruction();
946   m_pc = m_nextpc;
947   m_nextpc = ~0;
867948
868   execute_instruction(asap);
869   asap->icount--;
949   execute_instruction();
950   m_icount--;
870951}
871952
872static void bsr_0(asap_state *asap)
953void asap_device::bsr_0()
873954{
874   asap->nextpc = asap->ppc + ((INT32)(asap->op.d << 10) >> 8);
955   m_nextpc = m_ppc + ((INT32)(m_op << 10) >> 8);
875956
876   fetch_instruction(asap);
877   asap->pc = asap->nextpc;
878   asap->nextpc = ~0;
957   fetch_instruction();
958   m_pc = m_nextpc;
959   m_nextpc = ~0;
879960
880   execute_instruction(asap);
881   asap->icount--;
961   execute_instruction();
962   m_icount--;
882963}
883964
884965/**************************** LEA ******************************/
885966
886static void lea(asap_state *asap)
967void asap_device::lea()
887968{
888   DSTVAL(asap) = SRC1VAL(asap) + (SRC2VAL(asap) << 2);
969   DSTVAL = SRC1VAL + (SRC2VAL << 2);
889970}
890971
891static void lea_c(asap_state *asap)
972void asap_device::lea_c()
892973{
893   UINT32 src1 = SRC1VAL(asap);
894   UINT32 src2 = SRC2VAL(asap);
974   UINT32 src1 = SRC1VAL;
975   UINT32 src2 = SRC2VAL;
895976   UINT32 dst = src1 + (src2 << 2);
896977
897   SET_ZNCV_ADD(asap, dst, src1, src2);
978   SET_ZNCV_ADD(dst, src1, src2);
898979   if (src1 & 0xc0000000)
899      SET_CFLAG(asap, 1);
980      SET_CFLAG(1);
900981   if (((src1 ^ (src1 >> 1)) & 0x20000000) || (src1 ^ (src1 >> 2)) & 0x20000000)
901      SET_VFLAG(asap, 1);
902   DSTVAL(asap) = dst;
982      SET_VFLAG(1);
983   DSTVAL = dst;
903984}
904985
905static void lea_c0(asap_state *asap)
986void asap_device::lea_c0()
906987{
907   UINT32 src1 = SRC1VAL(asap);
908   UINT32 src2 = SRC2VAL(asap);
988   UINT32 src1 = SRC1VAL;
989   UINT32 src2 = SRC2VAL;
909990   UINT32 dst = src1 + (src2 << 2);
910991
911   SET_ZNCV_ADD(asap, dst, src1, src2);
992   SET_ZNCV_ADD(dst, src1, src2);
912993   if (src1 & 0xc0000000)
913      SET_CFLAG(asap, 1);
994      SET_CFLAG(1);
914995   if (((src1 ^ (src1 >> 1)) & 0x20000000) || (src1 ^ (src1 >> 2)) & 0x20000000)
915      SET_VFLAG(asap, 1);
996      SET_VFLAG(1);
916997}
917998
918999/**************************** LEAH ******************************/
9191000
920static void leah(asap_state *asap)
1001void asap_device::leah()
9211002{
922   DSTVAL(asap) = SRC1VAL(asap) + (SRC2VAL(asap) << 1);
1003   DSTVAL = SRC1VAL + (SRC2VAL << 1);
9231004}
9241005
925static void leah_c(asap_state *asap)
1006void asap_device::leah_c()
9261007{
927   UINT32 src1 = SRC1VAL(asap);
928   UINT32 src2 = SRC2VAL(asap);
1008   UINT32 src1 = SRC1VAL;
1009   UINT32 src2 = SRC2VAL;
9291010   UINT32 dst = src1 + (src2 << 1);
9301011
931   SET_ZNCV_ADD(asap, dst, src1, src2);
1012   SET_ZNCV_ADD(dst, src1, src2);
9321013   if (src1 & 0x80000000)
933      SET_CFLAG(asap, 1);
1014      SET_CFLAG(1);
9341015   if ((src1 ^ (src1 >> 1)) & 0x40000000)
935      SET_VFLAG(asap, 1);
936   DSTVAL(asap) = dst;
1016      SET_VFLAG(1);
1017   DSTVAL = dst;
9371018}
9381019
939static void leah_c0(asap_state *asap)
1020void asap_device::leah_c0()
9401021{
941   UINT32 src1 = SRC1VAL(asap);
942   UINT32 src2 = SRC2VAL(asap);
1022   UINT32 src1 = SRC1VAL;
1023   UINT32 src2 = SRC2VAL;
9431024   UINT32 dst = src1 + (src2 << 1);
9441025
945   SET_ZNCV_ADD(asap, dst, src1, src2);
1026   SET_ZNCV_ADD(dst, src1, src2);
9461027   if (src1 & 0x80000000)
947      SET_CFLAG(asap, 1);
1028      SET_CFLAG(1);
9481029   if ((src1 ^ (src1 >> 1)) & 0x40000000)
949      SET_VFLAG(asap, 1);
1030      SET_VFLAG(1);
9501031}
9511032
9521033/**************************** SUBR ******************************/
9531034
954static void subr(asap_state *asap)
1035void asap_device::subr()
9551036{
956   DSTVAL(asap) = SRC2VAL(asap) - SRC1VAL(asap);
1037   DSTVAL = SRC2VAL - SRC1VAL;
9571038}
9581039
959static void subr_c(asap_state *asap)
1040void asap_device::subr_c()
9601041{
961   UINT32 src1 = SRC1VAL(asap);
962   UINT32 src2 = SRC2VAL(asap);
1042   UINT32 src1 = SRC1VAL;
1043   UINT32 src2 = SRC2VAL;
9631044   UINT32 dst = src2 - src1;
9641045
965   SET_ZNCV_SUB(asap, dst, src2, src1);
966   DSTVAL(asap) = dst;
1046   SET_ZNCV_SUB(dst, src2, src1);
1047   DSTVAL = dst;
9671048}
9681049
969static void subr_c0(asap_state *asap)
1050void asap_device::subr_c0()
9701051{
971   UINT32 src1 = SRC1VAL(asap);
972   UINT32 src2 = SRC2VAL(asap);
1052   UINT32 src1 = SRC1VAL;
1053   UINT32 src2 = SRC2VAL;
9731054   UINT32 dst = src2 - src1;
9741055
975   SET_ZNCV_SUB(asap, dst, src2, src1);
1056   SET_ZNCV_SUB(dst, src2, src1);
9761057}
9771058
9781059/**************************** XOR ******************************/
9791060
980static void xor_(asap_state *asap)
1061void asap_device::xor_()
9811062{
982   DSTVAL(asap) = SRC1VAL(asap) ^ SRC2VAL(asap);
1063   DSTVAL = SRC1VAL ^ SRC2VAL;
9831064}
9841065
985static void xor_c(asap_state *asap)
1066void asap_device::xor_c()
9861067{
987   UINT32 dst = SRC1VAL(asap) ^ SRC2VAL(asap);
988   SET_ZN(asap, dst);
989   DSTVAL(asap) = dst;
1068   UINT32 dst = SRC1VAL ^ SRC2VAL;
1069   SET_ZN(dst);
1070   DSTVAL = dst;
9901071}
9911072
992static void xor_c0(asap_state *asap)
1073void asap_device::xor_c0()
9931074{
994   UINT32 dst = SRC1VAL(asap) ^ SRC2VAL(asap);
995   SET_ZN(asap, dst);
1075   UINT32 dst = SRC1VAL ^ SRC2VAL;
1076   SET_ZN(dst);
9961077}
9971078
9981079/**************************** XOR ******************************/
9991080
1000static void xorn(asap_state *asap)
1081void asap_device::xorn()
10011082{
1002   DSTVAL(asap) = SRC1VAL(asap) ^ ~SRC2VAL(asap);
1083   DSTVAL = SRC1VAL ^ ~SRC2VAL;
10031084}
10041085
1005static void xorn_c(asap_state *asap)
1086void asap_device::xorn_c()
10061087{
1007   UINT32 dst = SRC1VAL(asap) ^ ~SRC2VAL(asap);
1008   SET_ZN(asap, dst);
1009   DSTVAL(asap) = dst;
1088   UINT32 dst = SRC1VAL ^ ~SRC2VAL;
1089   SET_ZN(dst);
1090   DSTVAL = dst;
10101091}
10111092
1012static void xorn_c0(asap_state *asap)
1093void asap_device::xorn_c0()
10131094{
1014   UINT32 dst = SRC1VAL(asap) ^ ~SRC2VAL(asap);
1015   SET_ZN(asap, dst);
1095   UINT32 dst = SRC1VAL ^ ~SRC2VAL;
1096   SET_ZN(dst);
10161097}
10171098
10181099/**************************** ADD ******************************/
10191100
1020static void add(asap_state *asap)
1101void asap_device::add()
10211102{
1022   DSTVAL(asap) = SRC1VAL(asap) + SRC2VAL(asap);
1103   DSTVAL = SRC1VAL + SRC2VAL;
10231104}
10241105
1025static void add_c(asap_state *asap)
1106void asap_device::add_c()
10261107{
1027   UINT32 src1 = SRC1VAL(asap);
1028   UINT32 src2 = SRC2VAL(asap);
1108   UINT32 src1 = SRC1VAL;
1109   UINT32 src2 = SRC2VAL;
10291110   UINT32 dst = src1 + src2;
10301111
1031   SET_ZNCV_ADD(asap, dst, src1, src2);
1032   DSTVAL(asap) = dst;
1112   SET_ZNCV_ADD(dst, src1, src2);
1113   DSTVAL = dst;
10331114}
10341115
1035static void add_c0(asap_state *asap)
1116void asap_device::add_c0()
10361117{
1037   UINT32 src1 = SRC1VAL(asap);
1038   UINT32 src2 = SRC2VAL(asap);
1118   UINT32 src1 = SRC1VAL;
1119   UINT32 src2 = SRC2VAL;
10391120   UINT32 dst = src1 + src2;
10401121
1041   SET_ZNCV_ADD(asap, dst, src1, src2);
1122   SET_ZNCV_ADD(dst, src1, src2);
10421123}
10431124
10441125/**************************** ADD ******************************/
10451126
1046static void sub(asap_state *asap)
1127void asap_device::sub()
10471128{
1048   DSTVAL(asap) = SRC1VAL(asap) - SRC2VAL(asap);
1129   DSTVAL = SRC1VAL - SRC2VAL;
10491130}
10501131
1051static void sub_c(asap_state *asap)
1132void asap_device::sub_c()
10521133{
1053   UINT32 src1 = SRC1VAL(asap);
1054   UINT32 src2 = SRC2VAL(asap);
1134   UINT32 src1 = SRC1VAL;
1135   UINT32 src2 = SRC2VAL;
10551136   UINT32 dst = src1 - src2;
10561137
1057   SET_ZNCV_SUB(asap, dst, src1, src2);
1058   DSTVAL(asap) = dst;
1138   SET_ZNCV_SUB(dst, src1, src2);
1139   DSTVAL = dst;
10591140}
10601141
1061static void sub_c0(asap_state *asap)
1142void asap_device::sub_c0()
10621143{
1063   UINT32 src1 = SRC1VAL(asap);
1064   UINT32 src2 = SRC2VAL(asap);
1144   UINT32 src1 = SRC1VAL;
1145   UINT32 src2 = SRC2VAL;
10651146   UINT32 dst = src1 - src2;
10661147
1067   SET_ZNCV_SUB(asap, dst, src1, src2);
1148   SET_ZNCV_SUB(dst, src1, src2);
10681149}
10691150
10701151/**************************** ADDC ******************************/
10711152
1072static void addc(asap_state *asap)
1153void asap_device::addc()
10731154{
1074   DSTVAL(asap) = SRC1VAL(asap) + SRC2VAL(asap) + asap->cflag;
1155   DSTVAL = SRC1VAL + SRC2VAL + m_cflag;
10751156}
10761157
1077static void addc_c(asap_state *asap)
1158void asap_device::addc_c()
10781159{
1079   UINT32 src1 = SRC1VAL(asap);
1080   UINT32 src2 = SRC2VAL(asap);
1081   UINT32 dst = src1 + src2 + asap->cflag;
1160   UINT32 src1 = SRC1VAL;
1161   UINT32 src2 = SRC2VAL;
1162   UINT32 dst = src1 + src2 + m_cflag;
10821163
1083   SET_ZNCV_ADD(asap, dst, src1, src2);
1084   DSTVAL(asap) = dst;
1164   SET_ZNCV_ADD(dst, src1, src2);
1165   DSTVAL = dst;
10851166}
10861167
1087static void addc_c0(asap_state *asap)
1168void asap_device::addc_c0()
10881169{
1089   UINT32 src1 = SRC1VAL(asap);
1090   UINT32 src2 = SRC2VAL(asap);
1091   UINT32 dst = src1 + src2 + asap->cflag;
1170   UINT32 src1 = SRC1VAL;
1171   UINT32 src2 = SRC2VAL;
1172   UINT32 dst = src1 + src2 + m_cflag;
10921173
1093   SET_ZNCV_ADD(asap, dst, src1, src2);
1174   SET_ZNCV_ADD(dst, src1, src2);
10941175}
10951176
10961177/**************************** SUBC ******************************/
10971178
1098static void subc(asap_state *asap)
1179void asap_device::subc()
10991180{
1100   DSTVAL(asap) = SRC1VAL(asap) - SRC2VAL(asap) - 1 + asap->cflag;
1181   DSTVAL = SRC1VAL - SRC2VAL - 1 + m_cflag;
11011182}
11021183
1103static void subc_c(asap_state *asap)
1184void asap_device::subc_c()
11041185{
1105   UINT32 src1 = SRC1VAL(asap);
1106   UINT32 src2 = SRC2VAL(asap);
1107   UINT32 dst = src1 - src2 - 1 + asap->cflag;
1186   UINT32 src1 = SRC1VAL;
1187   UINT32 src2 = SRC2VAL;
1188   UINT32 dst = src1 - src2 - 1 + m_cflag;
11081189
1109   SET_ZNCV_SUB(asap, dst, src1, src2);
1110   DSTVAL(asap) = dst;
1190   SET_ZNCV_SUB(dst, src1, src2);
1191   DSTVAL = dst;
11111192}
11121193
1113static void subc_c0(asap_state *asap)
1194void asap_device::subc_c0()
11141195{
1115   UINT32 src1 = SRC1VAL(asap);
1116   UINT32 src2 = SRC2VAL(asap);
1117   UINT32 dst = src1 - src2 - 1 + asap->cflag;
1196   UINT32 src1 = SRC1VAL;
1197   UINT32 src2 = SRC2VAL;
1198   UINT32 dst = src1 - src2 - 1 + m_cflag;
11181199
1119   SET_ZNCV_SUB(asap, dst, src1, src2);
1200   SET_ZNCV_SUB(dst, src1, src2);
11201201}
11211202
11221203/**************************** AND ******************************/
11231204
1124static void and_(asap_state *asap)
1205void asap_device::and_()
11251206{
1126   DSTVAL(asap) = SRC1VAL(asap) & SRC2VAL(asap);
1207   DSTVAL = SRC1VAL & SRC2VAL;
11271208}
11281209
1129static void and_c(asap_state *asap)
1210void asap_device::and_c()
11301211{
1131   UINT32 dst = SRC1VAL(asap) & SRC2VAL(asap);
1132   SET_ZN(asap, dst);
1133   DSTVAL(asap) = dst;
1212   UINT32 dst = SRC1VAL & SRC2VAL;
1213   SET_ZN(dst);
1214   DSTVAL = dst;
11341215}
11351216
1136static void and_c0(asap_state *asap)
1217void asap_device::and_c0()
11371218{
1138   UINT32 dst = SRC1VAL(asap) & SRC2VAL(asap);
1139   SET_ZN(asap, dst);
1219   UINT32 dst = SRC1VAL & SRC2VAL;
1220   SET_ZN(dst);
11401221}
11411222
11421223/**************************** ANDN ******************************/
11431224
1144static void andn(asap_state *asap)
1225void asap_device::andn()
11451226{
1146   DSTVAL(asap) = SRC1VAL(asap) & ~SRC2VAL(asap);
1227   DSTVAL = SRC1VAL & ~SRC2VAL;
11471228}
11481229
1149static void andn_c(asap_state *asap)
1230void asap_device::andn_c()
11501231{
1151   UINT32 dst = SRC1VAL(asap) & ~SRC2VAL(asap);
1152   SET_ZN(asap, dst);
1153   DSTVAL(asap) = dst;
1232   UINT32 dst = SRC1VAL & ~SRC2VAL;
1233   SET_ZN(dst);
1234   DSTVAL = dst;
11541235}
11551236
1156static void andn_c0(asap_state *asap)
1237void asap_device::andn_c0()
11571238{
1158   UINT32 dst = SRC1VAL(asap) & ~SRC2VAL(asap);
1159   SET_ZN(asap, dst);
1239   UINT32 dst = SRC1VAL & ~SRC2VAL;
1240   SET_ZN(dst);
11601241}
11611242
11621243/**************************** OR ******************************/
11631244
1164static void or_(asap_state *asap)
1245void asap_device::or_()
11651246{
1166   DSTVAL(asap) = SRC1VAL(asap) | SRC2VAL(asap);
1247   DSTVAL = SRC1VAL | SRC2VAL;
11671248}
11681249
1169static void or_c(asap_state *asap)
1250void asap_device::or_c()
11701251{
1171   UINT32 dst = SRC1VAL(asap) | SRC2VAL(asap);
1172   SET_ZN(asap, dst);
1173   DSTVAL(asap) = dst;
1252   UINT32 dst = SRC1VAL | SRC2VAL;
1253   SET_ZN(dst);
1254   DSTVAL = dst;
11741255}
11751256
1176static void or_c0(asap_state *asap)
1257void asap_device::or_c0()
11771258{
1178   UINT32 dst = SRC1VAL(asap) | SRC2VAL(asap);
1179   SET_ZN(asap, dst);
1259   UINT32 dst = SRC1VAL | SRC2VAL;
1260   SET_ZN(dst);
11801261}
11811262
11821263/**************************** ORN ******************************/
11831264
1184static void orn(asap_state *asap)
1265void asap_device::orn()
11851266{
1186   DSTVAL(asap) = SRC1VAL(asap) | ~SRC2VAL(asap);
1267   DSTVAL = SRC1VAL | ~SRC2VAL;
11871268}
11881269
1189static void orn_c(asap_state *asap)
1270void asap_device::orn_c()
11901271{
1191   UINT32 dst = SRC1VAL(asap) | ~SRC2VAL(asap);
1192   SET_ZN(asap, dst);
1193   DSTVAL(asap) = dst;
1272   UINT32 dst = SRC1VAL | ~SRC2VAL;
1273   SET_ZN(dst);
1274   DSTVAL = dst;
11941275}
11951276
1196static void orn_c0(asap_state *asap)
1277void asap_device::orn_c0()
11971278{
1198   UINT32 dst = SRC1VAL(asap) | ~SRC2VAL(asap);
1199   SET_ZN(asap, dst);
1279   UINT32 dst = SRC1VAL | ~SRC2VAL;
1280   SET_ZN(dst);
12001281}
12011282
12021283/**************************** LD ******************************/
12031284
1204static void ld(asap_state *asap)
1285void asap_device::ld()
12051286{
1206   DSTVAL(asap) = READLONG(asap, SRC1VAL(asap) + (SRC2VAL(asap) << 2));
1287   DSTVAL = readlong(SRC1VAL + (SRC2VAL << 2));
12071288}
12081289
1209static void ld_0(asap_state *asap)
1290void asap_device::ld_0()
12101291{
1211   READLONG(asap, SRC1VAL(asap) + (SRC2VAL(asap) << 2));
1292   readlong(SRC1VAL + (SRC2VAL << 2));
12121293}
12131294
1214static void ld_c(asap_state *asap)
1295void asap_device::ld_c()
12151296{
1216   UINT32 dst = READLONG(asap, SRC1VAL(asap) + (SRC2VAL(asap) << 2));
1217   SET_ZN(asap, dst);
1218   DSTVAL(asap) = dst;
1297   UINT32 dst = readlong(SRC1VAL + (SRC2VAL << 2));
1298   SET_ZN(dst);
1299   DSTVAL = dst;
12191300}
12201301
1221static void ld_c0(asap_state *asap)
1302void asap_device::ld_c0()
12221303{
1223   UINT32 dst = READLONG(asap, SRC1VAL(asap) + (SRC2VAL(asap) << 2));
1224   SET_ZN(asap, dst);
1304   UINT32 dst = readlong(SRC1VAL + (SRC2VAL << 2));
1305   SET_ZN(dst);
12251306}
12261307
12271308/**************************** LDH ******************************/
12281309
1229static void ldh(asap_state *asap)
1310void asap_device::ldh()
12301311{
1231   DSTVAL(asap) = (INT16)READWORD(asap, SRC1VAL(asap) + (SRC2VAL(asap) << 1));
1312   DSTVAL = (INT16)readword(SRC1VAL + (SRC2VAL << 1));
12321313}
12331314
1234static void ldh_0(asap_state *asap)
1315void asap_device::ldh_0()
12351316{
1236   READWORD(asap, SRC1VAL(asap) + (SRC2VAL(asap) << 1));
1317   readword(SRC1VAL + (SRC2VAL << 1));
12371318}
12381319
1239static void ldh_c(asap_state *asap)
1320void asap_device::ldh_c()
12401321{
1241   UINT32 dst = (INT16)READWORD(asap, SRC1VAL(asap) + (SRC2VAL(asap) << 1));
1242   SET_ZN(asap, dst);
1243   DSTVAL(asap) = dst;
1322   UINT32 dst = (INT16)readword(SRC1VAL + (SRC2VAL << 1));
1323   SET_ZN(dst);
1324   DSTVAL = dst;
12441325}
12451326
1246static void ldh_c0(asap_state *asap)
1327void asap_device::ldh_c0()
12471328{
1248   UINT32 dst = (INT16)READWORD(asap, SRC1VAL(asap) + (SRC2VAL(asap) << 1));
1249   SET_ZN(asap, dst);
1329   UINT32 dst = (INT16)readword(SRC1VAL + (SRC2VAL << 1));
1330   SET_ZN(dst);
12501331}
12511332
12521333/**************************** LDUH ******************************/
12531334
1254static void lduh(asap_state *asap)
1335void asap_device::lduh()
12551336{
1256   DSTVAL(asap) = READWORD(asap, SRC1VAL(asap) + (SRC2VAL(asap) << 1));
1337   DSTVAL = readword(SRC1VAL + (SRC2VAL << 1));
12571338}
12581339
1259static void lduh_0(asap_state *asap)
1340void asap_device::lduh_0()
12601341{
1261   READWORD(asap, SRC1VAL(asap) + (SRC2VAL(asap) << 1));
1342   readword(SRC1VAL + (SRC2VAL << 1));
12621343}
12631344
1264static void lduh_c(asap_state *asap)
1345void asap_device::lduh_c()
12651346{
1266   UINT32 dst = READWORD(asap, SRC1VAL(asap) + (SRC2VAL(asap) << 1));
1267   SET_ZN(asap, dst);
1268   DSTVAL(asap) = dst;
1347   UINT32 dst = readword(SRC1VAL + (SRC2VAL << 1));
1348   SET_ZN(dst);
1349   DSTVAL = dst;
12691350}
12701351
1271static void lduh_c0(asap_state *asap)
1352void asap_device::lduh_c0()
12721353{
1273   UINT32 dst = READWORD(asap, SRC1VAL(asap) + (SRC2VAL(asap) << 1));
1274   SET_ZN(asap, dst);
1354   UINT32 dst = readword(SRC1VAL + (SRC2VAL << 1));
1355   SET_ZN(dst);
12751356}
12761357
12771358/**************************** STH ******************************/
12781359
1279static void sth(asap_state *asap)
1360void asap_device::sth()
12801361{
1281   WRITEWORD(asap, SRC1VAL(asap) + (SRC2VAL(asap) << 1), DSTVAL(asap));
1362   writeword(SRC1VAL + (SRC2VAL << 1), DSTVAL);
12821363}
12831364
1284static void sth_0(asap_state *asap)
1365void asap_device::sth_0()
12851366{
1286   WRITEWORD(asap, SRC1VAL(asap) + (SRC2VAL(asap) << 1), 0);
1367   writeword(SRC1VAL + (SRC2VAL << 1), 0);
12871368}
12881369
1289static void sth_c(asap_state *asap)
1370void asap_device::sth_c()
12901371{
1291   UINT32 dst = (UINT16)DSTVAL(asap);
1292   SET_ZN(asap, dst);
1293   WRITEWORD(asap, SRC1VAL(asap) + (SRC2VAL(asap) << 1), dst);
1372   UINT32 dst = (UINT16)DSTVAL;
1373   SET_ZN(dst);
1374   writeword(SRC1VAL + (SRC2VAL << 1), dst);
12941375}
12951376
1296static void sth_c0(asap_state *asap)
1377void asap_device::sth_c0()
12971378{
1298   SET_ZN(asap, 0);
1299   WRITEWORD(asap, SRC1VAL(asap) + (SRC2VAL(asap) << 1), 0);
1379   SET_ZN(0);
1380   writeword(SRC1VAL + (SRC2VAL << 1), 0);
13001381}
13011382
13021383/**************************** ST ******************************/
13031384
1304static void st(asap_state *asap)
1385void asap_device::st()
13051386{
1306   WRITELONG(asap, SRC1VAL(asap) + (SRC2VAL(asap) << 2), DSTVAL(asap));
1387   writelong(SRC1VAL + (SRC2VAL << 2), DSTVAL);
13071388}
13081389
1309static void st_0(asap_state *asap)
1390void asap_device::st_0()
13101391{
1311   WRITELONG(asap, SRC1VAL(asap) + (SRC2VAL(asap) << 2), 0);
1392   writelong(SRC1VAL + (SRC2VAL << 2), 0);
13121393}
13131394
1314static void st_c(asap_state *asap)
1395void asap_device::st_c()
13151396{
1316   UINT32 dst = DSTVAL(asap);
1317   SET_ZN(asap, dst);
1318   WRITELONG(asap, SRC1VAL(asap) + (SRC2VAL(asap) << 2), dst);
1397   UINT32 dst = DSTVAL;
1398   SET_ZN(dst);
1399   writelong(SRC1VAL + (SRC2VAL << 2), dst);
13191400}
13201401
1321static void st_c0(asap_state *asap)
1402void asap_device::st_c0()
13221403{
1323   SET_ZN(asap, 0);
1324   WRITELONG(asap, SRC1VAL(asap) + (SRC2VAL(asap) << 2), 0);
1404   SET_ZN(0);
1405   writelong(SRC1VAL + (SRC2VAL << 2), 0);
13251406}
13261407
13271408/**************************** LDB ******************************/
13281409
1329static void ldb(asap_state *asap)
1410void asap_device::ldb()
13301411{
1331   DSTVAL(asap) = (INT8)READBYTE(asap, SRC1VAL(asap) + SRC2VAL(asap));
1412   DSTVAL = (INT8)readbyte(SRC1VAL + SRC2VAL);
13321413}
13331414
1334static void ldb_0(asap_state *asap)
1415void asap_device::ldb_0()
13351416{
1336   READBYTE(asap, SRC1VAL(asap) + SRC2VAL(asap));
1417   readbyte(SRC1VAL + SRC2VAL);
13371418}
13381419
1339static void ldb_c(asap_state *asap)
1420void asap_device::ldb_c()
13401421{
1341   UINT32 dst = (INT8)READBYTE(asap, SRC1VAL(asap) + SRC2VAL(asap));
1342   SET_ZN(asap, dst);
1343   DSTVAL(asap) = dst;
1422   UINT32 dst = (INT8)readbyte(SRC1VAL + SRC2VAL);
1423   SET_ZN(dst);
1424   DSTVAL = dst;
13441425}
13451426
1346static void ldb_c0(asap_state *asap)
1427void asap_device::ldb_c0()
13471428{
1348   UINT32 dst = (INT8)READBYTE(asap, SRC1VAL(asap) + SRC2VAL(asap));
1349   SET_ZN(asap, dst);
1429   UINT32 dst = (INT8)readbyte(SRC1VAL + SRC2VAL);
1430   SET_ZN(dst);
13501431}
13511432
13521433/**************************** LDUB ******************************/
13531434
1354static void ldub(asap_state *asap)
1435void asap_device::ldub()
13551436{
1356   DSTVAL(asap) = READBYTE(asap, SRC1VAL(asap) + SRC2VAL(asap));
1437   DSTVAL = readbyte(SRC1VAL + SRC2VAL);
13571438}
13581439
1359static void ldub_0(asap_state *asap)
1440void asap_device::ldub_0()
13601441{
1361   READBYTE(asap, SRC1VAL(asap) + SRC2VAL(asap));
1442   readbyte(SRC1VAL + SRC2VAL);
13621443}
13631444
1364static void ldub_c(asap_state *asap)
1445void asap_device::ldub_c()
13651446{
1366   UINT32 dst = READBYTE(asap, SRC1VAL(asap) + SRC2VAL(asap));
1367   SET_ZN(asap, dst);
1368   DSTVAL(asap) = dst;
1447   UINT32 dst = readbyte(SRC1VAL + SRC2VAL);
1448   SET_ZN(dst);
1449   DSTVAL = dst;
13691450}
13701451
1371static void ldub_c0(asap_state *asap)
1452void asap_device::ldub_c0()
13721453{
1373   UINT32 dst = READBYTE(asap, SRC1VAL(asap) + SRC2VAL(asap));
1374   SET_ZN(asap, dst);
1454   UINT32 dst = readbyte(SRC1VAL + SRC2VAL);
1455   SET_ZN(dst);
13751456}
13761457
13771458/**************************** STB ******************************/
13781459
1379static void stb(asap_state *asap)
1460void asap_device::stb()
13801461{
1381   WRITEBYTE(asap, SRC1VAL(asap) + SRC2VAL(asap), DSTVAL(asap));
1462   writebyte(SRC1VAL + SRC2VAL, DSTVAL);
13821463}
13831464
1384static void stb_0(asap_state *asap)
1465void asap_device::stb_0()
13851466{
1386   WRITEBYTE(asap, SRC1VAL(asap) + SRC2VAL(asap), 0);
1467   writebyte(SRC1VAL + SRC2VAL, 0);
13871468}
13881469
1389static void stb_c(asap_state *asap)
1470void asap_device::stb_c()
13901471{
1391   UINT32 dst = (UINT8)DSTVAL(asap);
1392   SET_ZN(asap, dst);
1393   WRITEBYTE(asap, SRC1VAL(asap) + SRC2VAL(asap), dst);
1472   UINT32 dst = (UINT8)DSTVAL;
1473   SET_ZN(dst);
1474   writebyte(SRC1VAL + SRC2VAL, dst);
13941475}
13951476
1396static void stb_c0(asap_state *asap)
1477void asap_device::stb_c0()
13971478{
1398   SET_ZN(asap, 0);
1399   WRITEBYTE(asap, SRC1VAL(asap) + SRC2VAL(asap), 0);
1479   SET_ZN(0);
1480   writebyte(SRC1VAL + SRC2VAL, 0);
14001481}
14011482
14021483/**************************** ASHR ******************************/
14031484
1404static void ashr(asap_state *asap)
1485void asap_device::ashr()
14051486{
1406   UINT32 src2 = SRC2VAL(asap);
1407   DSTVAL(asap) = (src2 < 32) ? ((INT32)SRC1VAL(asap) >> src2) : ((INT32)SRC1VAL(asap) >> 31);
1487   UINT32 src2 = SRC2VAL;
1488   DSTVAL = (src2 < 32) ? ((INT32)SRC1VAL >> src2) : ((INT32)SRC1VAL >> 31);
14081489}
14091490
1410static void ashr_c(asap_state *asap)
1491void asap_device::ashr_c()
14111492{
1412   UINT32 src2 = SRC2VAL(asap);
1413   asap->cflag = 0;
1493   UINT32 src2 = SRC2VAL;
1494   m_cflag = 0;
14141495   if (src2 < 32)
14151496   {
1416      UINT32 src1 = SRC1VAL(asap);
1497      UINT32 src1 = SRC1VAL;
14171498      UINT32 dst = (INT32)src1 >> src2;
1418      SET_ZN(asap, dst);
1499      SET_ZN(dst);
14191500      if (src2 != 0)
14201501      {
14211502         src1 = src1 << (32 - src2);
1422         asap->cflag = src1 >> 31;
1503         m_cflag = src1 >> 31;
14231504      }
1424      DSTVAL(asap) = dst;
1505      DSTVAL = dst;
14251506   }
14261507   else
14271508   {
1428      UINT32 dst = (INT32)SRC1VAL(asap) >> 31;
1429      SET_ZN(asap, dst);
1430      DSTVAL(asap) = dst;
1509      UINT32 dst = (INT32)SRC1VAL >> 31;
1510      SET_ZN(dst);
1511      DSTVAL = dst;
14311512   }
14321513}
14331514
1434static void ashr_c0(asap_state *asap)
1515void asap_device::ashr_c0()
14351516{
1436   UINT32 src2 = SRC2VAL(asap);
1437   asap->cflag = 0;
1517   UINT32 src2 = SRC2VAL;
1518   m_cflag = 0;
14381519   if (src2 < 32)
14391520   {
1440      UINT32 src1 = SRC1VAL(asap);
1521      UINT32 src1 = SRC1VAL;
14411522      UINT32 dst = (INT32)src1 >> src2;
1442      SET_ZN(asap, dst);
1523      SET_ZN(dst);
14431524      if (src2 != 0)
14441525      {
14451526         src1 = src1 << (32 - src2);
1446         asap->cflag = src1 >> 31;
1527         m_cflag = src1 >> 31;
14471528      }
14481529   }
14491530   else
14501531   {
1451      UINT32 dst = (INT32)SRC1VAL(asap) >> 31;
1452      SET_ZN(asap, dst);
1532      UINT32 dst = (INT32)SRC1VAL >> 31;
1533      SET_ZN(dst);
14531534   }
14541535}
14551536
14561537/**************************** LSHR ******************************/
14571538
1458static void lshr(asap_state *asap)
1539void asap_device::lshr()
14591540{
1460   UINT32 src2 = SRC2VAL(asap);
1461   DSTVAL(asap) = (src2 < 32) ? (SRC1VAL(asap) >> src2) : (SRC1VAL(asap) >> 31);
1541   UINT32 src2 = SRC2VAL;
1542   DSTVAL = (src2 < 32) ? (SRC1VAL >> src2) : (SRC1VAL >> 31);
14621543}
14631544
1464static void lshr_c(asap_state *asap)
1545void asap_device::lshr_c()
14651546{
1466   UINT32 src2 = SRC2VAL(asap);
1467   asap->cflag = 0;
1547   UINT32 src2 = SRC2VAL;
1548   m_cflag = 0;
14681549   if (src2 < 32)
14691550   {
1470      UINT32 src1 = SRC1VAL(asap);
1551      UINT32 src1 = SRC1VAL;
14711552      UINT32 dst = src1 >> src2;
1472      SET_ZN(asap, dst);
1553      SET_ZN(dst);
14731554      if (src2 != 0)
14741555      {
14751556         src1 = src1 << (32 - src2);
1476         asap->cflag = src1 >> 31;
1557         m_cflag = src1 >> 31;
14771558      }
1478      DSTVAL(asap) = dst;
1559      DSTVAL = dst;
14791560   }
14801561   else
14811562   {
1482      UINT32 dst = SRC1VAL(asap) >> 31;
1483      SET_ZN(asap, dst);
1484      DSTVAL(asap) = dst;
1563      UINT32 dst = SRC1VAL >> 31;
1564      SET_ZN(dst);
1565      DSTVAL = dst;
14851566   }
14861567}
14871568
1488static void lshr_c0(asap_state *asap)
1569void asap_device::lshr_c0()
14891570{
1490   UINT32 src2 = SRC2VAL(asap);
1491   asap->cflag = 0;
1571   UINT32 src2 = SRC2VAL;
1572   m_cflag = 0;
14921573   if (src2 < 32)
14931574   {
1494      UINT32 src1 = SRC1VAL(asap);
1575      UINT32 src1 = SRC1VAL;
14951576      UINT32 dst = src1 >> src2;
1496      SET_ZN(asap, dst);
1577      SET_ZN(dst);
14971578      if (src2 != 0)
14981579      {
14991580         src1 = src1 << (32 - src2);
1500         asap->cflag = src1 >> 31;
1581         m_cflag = src1 >> 31;
15011582      }
15021583   }
15031584   else
15041585   {
1505      SET_ZN(asap, 0);
1506      DSTVAL(asap) = 0;
1586      SET_ZN(0);
1587      DSTVAL = 0;
15071588   }
15081589}
15091590
15101591/**************************** ASHL ******************************/
15111592
1512static void ashl(asap_state *asap)
1593void asap_device::ashl()
15131594{
1514   UINT32 src2 = SRC2VAL(asap);
1515   DSTVAL(asap) = (src2 < 32) ? (SRC1VAL(asap) << src2) : 0;
1595   UINT32 src2 = SRC2VAL;
1596   DSTVAL = (src2 < 32) ? (SRC1VAL << src2) : 0;
15161597}
15171598
1518static void ashl_c(asap_state *asap)
1599void asap_device::ashl_c()
15191600{
1520   UINT32 src2 = SRC2VAL(asap);
1521   asap->cflag = asap->vflag = 0;
1601   UINT32 src2 = SRC2VAL;
1602   m_cflag = m_vflag = 0;
15221603   if (src2 < 32)
15231604   {
1524      UINT32 src1 = SRC1VAL(asap);
1605      UINT32 src1 = SRC1VAL;
15251606      UINT32 dst = src1 << src2;
1526      SET_ZN(asap, dst);
1607      SET_ZN(dst);
15271608      if (src2 != 0)
15281609      {
15291610         src1 = (INT32)src1 >> (32 - src2);
1530         asap->cflag = src1 & PS_CFLAG;
1531         asap->vflag = (src1 != ((INT32)dst >> 31)) << 31;
1611         m_cflag = src1 & PS_CFLAG;
1612         m_vflag = (src1 != ((INT32)dst >> 31)) << 31;
15321613      }
1533      DSTVAL(asap) = dst;
1614      DSTVAL = dst;
15341615   }
15351616   else
15361617   {
1537      SET_ZN(asap, 0);
1538      DSTVAL(asap) = 0;
1618      SET_ZN(0);
1619      DSTVAL = 0;
15391620   }
15401621}
15411622
1542static void ashl_c0(asap_state *asap)
1623void asap_device::ashl_c0()
15431624{
1544   UINT32 src2 = SRC2VAL(asap);
1545   asap->cflag = asap->vflag = 0;
1625   UINT32 src2 = SRC2VAL;
1626   m_cflag = m_vflag = 0;
15461627   if (src2 < 32)
15471628   {
1548      UINT32 src1 = SRC1VAL(asap);
1629      UINT32 src1 = SRC1VAL;
15491630      UINT32 dst = src1 << src2;
1550      SET_ZN(asap, dst);
1631      SET_ZN(dst);
15511632      if (src2 != 0)
15521633      {
15531634         src1 = (INT32)src1 >> (32 - src2);
1554         asap->cflag = src1 & PS_CFLAG;
1555         asap->vflag = (src1 != ((INT32)dst >> 31)) << 31;
1635         m_cflag = src1 & PS_CFLAG;
1636         m_vflag = (src1 != ((INT32)dst >> 31)) << 31;
15561637      }
15571638   }
15581639   else
1559      SET_ZN(asap, 0);
1640      SET_ZN(0);
15601641}
15611642
15621643/**************************** ROTL ******************************/
15631644
1564static void rotl(asap_state *asap)
1645void asap_device::rotl()
15651646{
1566   UINT32 src1 = SRC1VAL(asap);
1567   UINT32 src2 = SRC2VAL(asap) & 31;
1568   DSTVAL(asap) = (src1 << src2) | (src1 >> (32 - src2));
1647   UINT32 src1 = SRC1VAL;
1648   UINT32 src2 = SRC2VAL & 31;
1649   DSTVAL = (src1 << src2) | (src1 >> (32 - src2));
15691650}
15701651
1571static void rotl_c(asap_state *asap)
1652void asap_device::rotl_c()
15721653{
1573   UINT32 src1 = SRC1VAL(asap);
1574   UINT32 src2 = SRC2VAL(asap) & 31;
1654   UINT32 src1 = SRC1VAL;
1655   UINT32 src2 = SRC2VAL & 31;
15751656   UINT32 dst = (src1 << src2) | (src1 >> (32 - src2));
1576   SET_ZN(asap, dst);
1577   DSTVAL(asap) = dst;
1657   SET_ZN(dst);
1658   DSTVAL = dst;
15781659}
15791660
1580static void rotl_c0(asap_state *asap)
1661void asap_device::rotl_c0()
15811662{
1582   UINT32 src1 = SRC1VAL(asap);
1583   UINT32 src2 = SRC2VAL(asap) & 31;
1663   UINT32 src1 = SRC1VAL;
1664   UINT32 src2 = SRC2VAL & 31;
15841665   UINT32 dst = (src1 << src2) | (src1 >> (32 - src2));
1585   SET_ZN(asap, dst);
1666   SET_ZN(dst);
15861667}
15871668
15881669/**************************** GETPS ******************************/
15891670
1590static void getps(asap_state *asap)
1671void asap_device::getps()
15911672{
1592   DSTVAL(asap) = GET_FLAGS(asap);
1673   DSTVAL = GET_FLAGS();
15931674}
15941675
15951676/**************************** PUTPS ******************************/
15961677
1597static void putps(asap_state *asap)
1678void asap_device::putps()
15981679{
1599   UINT32 src2 = SRC2VAL(asap) & 0x3f;
1600   SET_FLAGS(asap, src2);
1601   check_irqs(asap);
1680   UINT32 src2 = SRC2VAL & 0x3f;
1681   SET_FLAGS(src2);
1682   check_irqs();
16021683}
16031684
16041685/**************************** JSR ******************************/
16051686
1606static void jsr(asap_state *asap)
1687void asap_device::jsr()
16071688{
1608   DSTVAL(asap) = asap->pc + 4;
1609   asap->nextpc = SRC1VAL(asap) + (SRC2VAL(asap) << 2);
1689   DSTVAL = m_pc + 4;
1690   m_nextpc = SRC1VAL + (SRC2VAL << 2);
16101691
1611   fetch_instruction(asap);
1612   asap->pc = asap->nextpc;
1613   asap->nextpc = ~0;
1692   fetch_instruction();
1693   m_pc = m_nextpc;
1694   m_nextpc = ~0;
16141695
1615   execute_instruction(asap);
1616   asap->icount--;
1696   execute_instruction();
1697   m_icount--;
16171698}
16181699
1619static void jsr_0(asap_state *asap)
1700void asap_device::jsr_0()
16201701{
1621   asap->nextpc = SRC1VAL(asap) + (SRC2VAL(asap) << 2);
1702   m_nextpc = SRC1VAL + (SRC2VAL << 2);
16221703
1623   fetch_instruction(asap);
1624   asap->pc = asap->nextpc;
1625   asap->nextpc = ~0;
1704   fetch_instruction();
1705   m_pc = m_nextpc;
1706   m_nextpc = ~0;
16261707
1627   execute_instruction(asap);
1628   asap->icount--;
1708   execute_instruction();
1709   m_icount--;
16291710}
16301711
1631static void jsr_c(asap_state *asap)
1712void asap_device::jsr_c()
16321713{
1633   DSTVAL(asap) = asap->pc + 4;
1634   asap->nextpc = SRC1VAL(asap) + (SRC2VAL(asap) << 2);
1635   asap->iflag = asap->pflag;
1714   DSTVAL = m_pc + 4;
1715   m_nextpc = SRC1VAL + (SRC2VAL << 2);
1716   m_iflag = m_pflag;
16361717
1637   fetch_instruction(asap);
1638   asap->pc = asap->nextpc;
1639   asap->nextpc = ~0;
1718   fetch_instruction();
1719   m_pc = m_nextpc;
1720   m_nextpc = ~0;
16401721
1641   execute_instruction(asap);
1642   asap->icount--;
1643   check_irqs(asap);
1722   execute_instruction();
1723   m_icount--;
1724   check_irqs();
16441725}
16451726
1646static void jsr_c0(asap_state *asap)
1727void asap_device::jsr_c0()
16471728{
1648   asap->nextpc = SRC1VAL(asap) + (SRC2VAL(asap) << 2);
1649   asap->iflag = asap->pflag;
1729   m_nextpc = SRC1VAL + (SRC2VAL << 2);
1730   m_iflag = m_pflag;
16501731
1651   fetch_instruction(asap);
1652   asap->pc = asap->nextpc;
1653   asap->nextpc = ~0;
1732   fetch_instruction();
1733   m_pc = m_nextpc;
1734   m_nextpc = ~0;
16541735
1655   execute_instruction(asap);
1656   asap->icount--;
1657   check_irqs(asap);
1736   execute_instruction();
1737   m_icount--;
1738   check_irqs();
16581739}
16591740
16601741/**************************** TRAP F ******************************/
16611742
1662static void trapf(asap_state *asap)
1743void asap_device::trapf()
16631744{
1664   generate_exception(asap, EXCEPTION_TRAPF);
1745   generate_exception(EXCEPTION_TRAPF);
16651746}
16661747
16671748
1668/**************************************************************************
1669 * Generic set_info
1670 **************************************************************************/
16711749
1672static CPU_SET_INFO( asap )
1673{
1674   asap_state *asap = get_safe_token(device);
1675
1676   switch (state)
1677   {
1678      /* --- the following bits of info are set as 64-bit signed integers --- */
1679      case CPUINFO_INT_INPUT_STATE + ASAP_IRQ0:   set_irq_line(asap, ASAP_IRQ0, info->i);      break;
1680
1681      case CPUINFO_INT_PC:
1682      case CPUINFO_INT_REGISTER + ASAP_PC:   asap->pc = info->i;                        break;
1683      case CPUINFO_INT_REGISTER + ASAP_PS:   SET_FLAGS(asap, info->i);                  break;
1684
1685      case CPUINFO_INT_REGISTER + ASAP_R0:   asap->src2val[REGBASE + 0] = info->i;         break;
1686      case CPUINFO_INT_REGISTER + ASAP_R1:   asap->src2val[REGBASE + 1] = info->i;         break;
1687      case CPUINFO_INT_REGISTER + ASAP_R2:   asap->src2val[REGBASE + 2] = info->i;         break;
1688      case CPUINFO_INT_REGISTER + ASAP_R3:   asap->src2val[REGBASE + 3] = info->i;         break;
1689      case CPUINFO_INT_REGISTER + ASAP_R4:   asap->src2val[REGBASE + 4] = info->i;         break;
1690      case CPUINFO_INT_REGISTER + ASAP_R5:   asap->src2val[REGBASE + 5] = info->i;         break;
1691      case CPUINFO_INT_REGISTER + ASAP_R6:   asap->src2val[REGBASE + 6] = info->i;         break;
1692      case CPUINFO_INT_REGISTER + ASAP_R7:   asap->src2val[REGBASE + 7] = info->i;         break;
1693      case CPUINFO_INT_REGISTER + ASAP_R8:   asap->src2val[REGBASE + 8] = info->i;         break;
1694      case CPUINFO_INT_REGISTER + ASAP_R9:   asap->src2val[REGBASE + 9] = info->i;         break;
1695      case CPUINFO_INT_REGISTER + ASAP_R10:   asap->src2val[REGBASE + 10] = info->i;         break;
1696      case CPUINFO_INT_REGISTER + ASAP_R11:   asap->src2val[REGBASE + 11] = info->i;         break;
1697      case CPUINFO_INT_REGISTER + ASAP_R12:   asap->src2val[REGBASE + 12] = info->i;         break;
1698      case CPUINFO_INT_REGISTER + ASAP_R13:   asap->src2val[REGBASE + 13] = info->i;         break;
1699      case CPUINFO_INT_REGISTER + ASAP_R14:   asap->src2val[REGBASE + 14] = info->i;         break;
1700      case CPUINFO_INT_REGISTER + ASAP_R15:   asap->src2val[REGBASE + 15] = info->i;         break;
1701      case CPUINFO_INT_REGISTER + ASAP_R16:   asap->src2val[REGBASE + 16] = info->i;         break;
1702      case CPUINFO_INT_REGISTER + ASAP_R17:   asap->src2val[REGBASE + 17] = info->i;         break;
1703      case CPUINFO_INT_REGISTER + ASAP_R18:   asap->src2val[REGBASE + 18] = info->i;         break;
1704      case CPUINFO_INT_REGISTER + ASAP_R19:   asap->src2val[REGBASE + 19] = info->i;         break;
1705      case CPUINFO_INT_REGISTER + ASAP_R20:   asap->src2val[REGBASE + 20] = info->i;         break;
1706      case CPUINFO_INT_REGISTER + ASAP_R21:   asap->src2val[REGBASE + 21] = info->i;         break;
1707      case CPUINFO_INT_REGISTER + ASAP_R22:   asap->src2val[REGBASE + 22] = info->i;         break;
1708      case CPUINFO_INT_REGISTER + ASAP_R23:   asap->src2val[REGBASE + 23] = info->i;         break;
1709      case CPUINFO_INT_REGISTER + ASAP_R24:   asap->src2val[REGBASE + 24] = info->i;         break;
1710      case CPUINFO_INT_REGISTER + ASAP_R25:   asap->src2val[REGBASE + 25] = info->i;         break;
1711      case CPUINFO_INT_REGISTER + ASAP_R26:   asap->src2val[REGBASE + 26] = info->i;         break;
1712      case CPUINFO_INT_REGISTER + ASAP_R27:   asap->src2val[REGBASE + 27] = info->i;         break;
1713      case CPUINFO_INT_REGISTER + ASAP_R28:   asap->src2val[REGBASE + 28] = info->i;         break;
1714      case CPUINFO_INT_REGISTER + ASAP_R29:   asap->src2val[REGBASE + 29] = info->i;         break;
1715      case CPUINFO_INT_REGISTER + ASAP_R30:   asap->src2val[REGBASE + 30] = info->i;         break;
1716      case CPUINFO_INT_SP:
1717      case CPUINFO_INT_REGISTER + ASAP_R31:   asap->src2val[REGBASE + 31] = info->i;         break;
1718   }
1719}
1720
1721
1722
1723/**************************************************************************
1724 * Generic get_info
1725 **************************************************************************/
1726
1727CPU_GET_INFO( asap )
1728{
1729   asap_state *asap = (device != NULL && device->token() != NULL) ? get_safe_token(device) : NULL;
1730
1731   switch (state)
1732   {
1733      /* --- the following bits of info are returned as 64-bit signed integers --- */
1734      case CPUINFO_INT_CONTEXT_SIZE:               info->i = sizeof(asap_state);         break;
1735      case CPUINFO_INT_INPUT_LINES:               info->i = 1;                     break;
1736      case CPUINFO_INT_DEFAULT_IRQ_VECTOR:         info->i = 0;                     break;
1737      case DEVINFO_INT_ENDIANNESS:               info->i = ENDIANNESS_LITTLE;               break;
1738      case CPUINFO_INT_CLOCK_MULTIPLIER:            info->i = 1;                     break;
1739      case CPUINFO_INT_CLOCK_DIVIDER:               info->i = 1;                     break;
1740      case CPUINFO_INT_MIN_INSTRUCTION_BYTES:         info->i = 4;                     break;
1741      case CPUINFO_INT_MAX_INSTRUCTION_BYTES:         info->i = 12;                     break;
1742      case CPUINFO_INT_MIN_CYCLES:               info->i = 1;                     break;
1743      case CPUINFO_INT_MAX_CYCLES:               info->i = 2;                     break;
1744
1745      case DEVINFO_INT_DATABUS_WIDTH + ADDRESS_SPACE_PROGRAM:   info->i = 32;               break;
1746      case DEVINFO_INT_ADDRBUS_WIDTH + ADDRESS_SPACE_PROGRAM: info->i = 32;               break;
1747      case DEVINFO_INT_ADDRBUS_SHIFT + ADDRESS_SPACE_PROGRAM: info->i = 0;               break;
1748      case DEVINFO_INT_DATABUS_WIDTH + ADDRESS_SPACE_DATA:   info->i = 0;               break;
1749      case DEVINFO_INT_ADDRBUS_WIDTH + ADDRESS_SPACE_DATA:   info->i = 0;               break;
1750      case DEVINFO_INT_ADDRBUS_SHIFT + ADDRESS_SPACE_DATA:   info->i = 0;               break;
1751      case DEVINFO_INT_DATABUS_WIDTH + ADDRESS_SPACE_IO:      info->i = 0;               break;
1752      case DEVINFO_INT_ADDRBUS_WIDTH + ADDRESS_SPACE_IO:      info->i = 0;               break;
1753      case DEVINFO_INT_ADDRBUS_SHIFT + ADDRESS_SPACE_IO:      info->i = 0;               break;
1754
1755      case CPUINFO_INT_INPUT_STATE + ASAP_IRQ0:      info->i = asap->irq_state;            break;
1756
1757      case CPUINFO_INT_PREVIOUSPC:               info->i = asap->ppc;               break;
1758
1759      case CPUINFO_INT_PC:
1760      case CPUINFO_INT_REGISTER + ASAP_PC:         info->i = asap->pc;                  break;
1761      case CPUINFO_INT_REGISTER + ASAP_PS:         info->i = GET_FLAGS(asap);            break;
1762
1763      case CPUINFO_INT_REGISTER + ASAP_R0:         info->i = asap->src2val[REGBASE + 0];   break;
1764      case CPUINFO_INT_REGISTER + ASAP_R1:         info->i = asap->src2val[REGBASE + 1];   break;
1765      case CPUINFO_INT_REGISTER + ASAP_R2:         info->i = asap->src2val[REGBASE + 2];   break;
1766      case CPUINFO_INT_REGISTER + ASAP_R3:         info->i = asap->src2val[REGBASE + 3];   break;
1767      case CPUINFO_INT_REGISTER + ASAP_R4:         info->i = asap->src2val[REGBASE + 4];   break;
1768      case CPUINFO_INT_REGISTER + ASAP_R5:         info->i = asap->src2val[REGBASE + 5];   break;
1769      case CPUINFO_INT_REGISTER + ASAP_R6:         info->i = asap->src2val[REGBASE + 6];   break;
1770      case CPUINFO_INT_REGISTER + ASAP_R7:         info->i = asap->src2val[REGBASE + 7];   break;
1771      case CPUINFO_INT_REGISTER + ASAP_R8:         info->i = asap->src2val[REGBASE + 8];   break;
1772      case CPUINFO_INT_REGISTER + ASAP_R9:         info->i = asap->src2val[REGBASE + 9];   break;
1773      case CPUINFO_INT_REGISTER + ASAP_R10:         info->i = asap->src2val[REGBASE + 10];   break;
1774      case CPUINFO_INT_REGISTER + ASAP_R11:         info->i = asap->src2val[REGBASE + 11];   break;
1775      case CPUINFO_INT_REGISTER + ASAP_R12:         info->i = asap->src2val[REGBASE + 12];   break;
1776      case CPUINFO_INT_REGISTER + ASAP_R13:         info->i = asap->src2val[REGBASE + 13];   break;
1777      case CPUINFO_INT_REGISTER + ASAP_R14:         info->i = asap->src2val[REGBASE + 14];   break;
1778      case CPUINFO_INT_REGISTER + ASAP_R15:         info->i = asap->src2val[REGBASE + 15];   break;
1779      case CPUINFO_INT_REGISTER + ASAP_R16:         info->i = asap->src2val[REGBASE + 16];   break;
1780      case CPUINFO_INT_REGISTER + ASAP_R17:         info->i = asap->src2val[REGBASE + 17];   break;
1781      case CPUINFO_INT_REGISTER + ASAP_R18:         info->i = asap->src2val[REGBASE + 18];   break;
1782      case CPUINFO_INT_REGISTER + ASAP_R19:         info->i = asap->src2val[REGBASE + 19];   break;
1783      case CPUINFO_INT_REGISTER + ASAP_R20:         info->i = asap->src2val[REGBASE + 20];   break;
1784      case CPUINFO_INT_REGISTER + ASAP_R21:         info->i = asap->src2val[REGBASE + 21];   break;
1785      case CPUINFO_INT_REGISTER + ASAP_R22:         info->i = asap->src2val[REGBASE + 22];   break;
1786      case CPUINFO_INT_REGISTER + ASAP_R23:         info->i = asap->src2val[REGBASE + 23];   break;
1787      case CPUINFO_INT_REGISTER + ASAP_R24:         info->i = asap->src2val[REGBASE + 24];   break;
1788      case CPUINFO_INT_REGISTER + ASAP_R25:         info->i = asap->src2val[REGBASE + 25];   break;
1789      case CPUINFO_INT_REGISTER + ASAP_R26:         info->i = asap->src2val[REGBASE + 26];   break;
1790      case CPUINFO_INT_REGISTER + ASAP_R27:         info->i = asap->src2val[REGBASE + 27];   break;
1791      case CPUINFO_INT_REGISTER + ASAP_R28:         info->i = asap->src2val[REGBASE + 28];   break;
1792      case CPUINFO_INT_REGISTER + ASAP_R29:         info->i = asap->src2val[REGBASE + 29];   break;
1793      case CPUINFO_INT_REGISTER + ASAP_R30:         info->i = asap->src2val[REGBASE + 30];   break;
1794      case CPUINFO_INT_REGISTER + ASAP_R31:         info->i = asap->src2val[REGBASE + 31];   break;
1795
1796      /* --- the following bits of info are returned as pointers to data or functions --- */
1797      case CPUINFO_FCT_SET_INFO:                  info->setinfo = CPU_SET_INFO_NAME(asap);      break;
1798      case CPUINFO_FCT_INIT:                     info->init = CPU_INIT_NAME(asap);            break;
1799      case CPUINFO_FCT_RESET:                     info->reset = CPU_RESET_NAME(asap);            break;
1800      case CPUINFO_FCT_EXIT:                     info->exit = CPU_EXIT_NAME(asap);            break;
1801      case CPUINFO_FCT_EXECUTE:                  info->execute = CPU_EXECUTE_NAME(asap);         break;
1802      case CPUINFO_FCT_BURN:                     info->burn = NULL;                        break;
1803      case CPUINFO_FCT_DISASSEMBLE:               info->disassemble = CPU_DISASSEMBLE_NAME(asap);   break;
1804      case CPUINFO_PTR_INSTRUCTION_COUNTER:         info->icount = &asap->icount;               break;
1805
1806      /* --- the following bits of info are returned as NULL-terminated strings --- */
1807      case DEVINFO_STR_NAME:                     strcpy(info->s, "ASAP");            break;
1808      case DEVINFO_STR_FAMILY:               strcpy(info->s, "Atari ASAP");         break;
1809      case DEVINFO_STR_VERSION:               strcpy(info->s, "1.0");               break;
1810      case DEVINFO_STR_SOURCE_FILE:                  strcpy(info->s, __FILE__);            break;
1811      case DEVINFO_STR_CREDITS:               strcpy(info->s, "Copyright Aaron Giles"); break;
1812
1813      case CPUINFO_STR_FLAGS:                     strcpy(info->s, " ");               break;
1814
1815      case CPUINFO_STR_REGISTER + ASAP_PC:         sprintf(info->s, "PC: %08X", asap->pc);   break;
1816      case CPUINFO_STR_REGISTER + ASAP_PS:         sprintf(info->s, "PS: %08X", GET_FLAGS(asap)); break;
1817
1818      case CPUINFO_STR_REGISTER + ASAP_R0:         sprintf(info->s, "R0: %08X", asap->src2val[REGBASE + 0]); break;
1819      case CPUINFO_STR_REGISTER + ASAP_R1:         sprintf(info->s, "R1: %08X", asap->src2val[REGBASE + 1]); break;
1820      case CPUINFO_STR_REGISTER + ASAP_R2:         sprintf(info->s, "R2: %08X", asap->src2val[REGBASE + 2]); break;
1821      case CPUINFO_STR_REGISTER + ASAP_R3:         sprintf(info->s, "R3: %08X", asap->src2val[REGBASE + 3]); break;
1822      case CPUINFO_STR_REGISTER + ASAP_R4:         sprintf(info->s, "R4: %08X", asap->src2val[REGBASE + 4]); break;
1823      case CPUINFO_STR_REGISTER + ASAP_R5:         sprintf(info->s, "R5: %08X", asap->src2val[REGBASE + 5]); break;
1824      case CPUINFO_STR_REGISTER + ASAP_R6:         sprintf(info->s, "R6: %08X", asap->src2val[REGBASE + 6]); break;
1825      case CPUINFO_STR_REGISTER + ASAP_R7:         sprintf(info->s, "R7: %08X", asap->src2val[REGBASE + 7]); break;
1826      case CPUINFO_STR_REGISTER + ASAP_R8:         sprintf(info->s, "R8: %08X", asap->src2val[REGBASE + 8]); break;
1827      case CPUINFO_STR_REGISTER + ASAP_R9:         sprintf(info->s, "R9: %08X", asap->src2val[REGBASE + 9]); break;
1828      case CPUINFO_STR_REGISTER + ASAP_R10:         sprintf(info->s, "R10:%08X", asap->src2val[REGBASE + 10]); break;
1829      case CPUINFO_STR_REGISTER + ASAP_R11:         sprintf(info->s, "R11:%08X", asap->src2val[REGBASE + 11]); break;
1830      case CPUINFO_STR_REGISTER + ASAP_R12:         sprintf(info->s, "R12:%08X", asap->src2val[REGBASE + 12]); break;
1831      case CPUINFO_STR_REGISTER + ASAP_R13:         sprintf(info->s, "R13:%08X", asap->src2val[REGBASE + 13]); break;
1832      case CPUINFO_STR_REGISTER + ASAP_R14:         sprintf(info->s, "R14:%08X", asap->src2val[REGBASE + 14]); break;
1833      case CPUINFO_STR_REGISTER + ASAP_R15:         sprintf(info->s, "R15:%08X", asap->src2val[REGBASE + 15]); break;
1834      case CPUINFO_STR_REGISTER + ASAP_R16:         sprintf(info->s, "R16:%08X", asap->src2val[REGBASE + 16]); break;
1835      case CPUINFO_STR_REGISTER + ASAP_R17:         sprintf(info->s, "R17:%08X", asap->src2val[REGBASE + 17]); break;
1836      case CPUINFO_STR_REGISTER + ASAP_R18:         sprintf(info->s, "R18:%08X", asap->src2val[REGBASE + 18]); break;
1837      case CPUINFO_STR_REGISTER + ASAP_R19:         sprintf(info->s, "R19:%08X", asap->src2val[REGBASE + 19]); break;
1838      case CPUINFO_STR_REGISTER + ASAP_R20:         sprintf(info->s, "R20:%08X", asap->src2val[REGBASE + 20]); break;
1839      case CPUINFO_STR_REGISTER + ASAP_R21:         sprintf(info->s, "R21:%08X", asap->src2val[REGBASE + 21]); break;
1840      case CPUINFO_STR_REGISTER + ASAP_R22:         sprintf(info->s, "R22:%08X", asap->src2val[REGBASE + 22]); break;
1841      case CPUINFO_STR_REGISTER + ASAP_R23:         sprintf(info->s, "R23:%08X", asap->src2val[REGBASE + 23]); break;
1842      case CPUINFO_STR_REGISTER + ASAP_R24:         sprintf(info->s, "R24:%08X", asap->src2val[REGBASE + 24]); break;
1843      case CPUINFO_STR_REGISTER + ASAP_R25:         sprintf(info->s, "R25:%08X", asap->src2val[REGBASE + 25]); break;
1844      case CPUINFO_STR_REGISTER + ASAP_R26:         sprintf(info->s, "R26:%08X", asap->src2val[REGBASE + 26]); break;
1845      case CPUINFO_STR_REGISTER + ASAP_R27:         sprintf(info->s, "R27:%08X", asap->src2val[REGBASE + 27]); break;
1846      case CPUINFO_STR_REGISTER + ASAP_R28:         sprintf(info->s, "R28:%08X", asap->src2val[REGBASE + 28]); break;
1847      case CPUINFO_STR_REGISTER + ASAP_R29:         sprintf(info->s, "R29:%08X", asap->src2val[REGBASE + 29]); break;
1848      case CPUINFO_STR_REGISTER + ASAP_R30:         sprintf(info->s, "R30:%08X", asap->src2val[REGBASE + 30]); break;
1849      case CPUINFO_STR_REGISTER + ASAP_R31:         sprintf(info->s, "R31:%08X", asap->src2val[REGBASE + 31]); break;
1850   }
1851}
1852
1853DEFINE_LEGACY_CPU_DEVICE(ASAP, asap);
1750const device_type ASAP = asap_device_config::static_alloc_device_config;
src/emu/cpu/asap/asap.h
r9060r9061
11/***************************************************************************
22
33    asap.h
4    Interface file for the portable Atari ASAP emulator.
5    Written by Aaron Giles
64
5    Core implementation for the portable ASAP emulator.
6    ASAP = Atari Simplified Architecture Processor
7
8****************************************************************************
9
10    Copyright Aaron Giles
11    All rights reserved.
12
13    Redistribution and use in source and binary forms, with or without
14    modification, are permitted provided that the following conditions are
15    met:
16
17        * Redistributions of source code must retain the above copyright
18          notice, this list of conditions and the following disclaimer.
19        * Redistributions in binary form must reproduce the above copyright
20          notice, this list of conditions and the following disclaimer in
21          the documentation and/or other materials provided with the
22          distribution.
23        * Neither the name 'MAME' nor the names of its contributors may be
24          used to endorse or promote products derived from this software
25          without specific prior written permission.
26
27    THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
28    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
29    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
30    DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
31    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
32    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
33    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
35    STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
36    IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37    POSSIBILITY OF SUCH DAMAGE.
38
739***************************************************************************/
840
941#pragma once
r9060r9061
1244#define __ASAP_H__
1345
1446
15/***************************************************************************
16    REGISTER ENUMERATION
17***************************************************************************/
47//**************************************************************************
48//  TYPE DEFINITIONS
49//**************************************************************************
1850
51
52// ======================> asap_device_config
53
54class asap_device_config :   public cpu_device_config
55{
56   friend class asap_device;
57
58   // construction/destruction
59   asap_device_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock);
60
61public:
62   // allocators
63   static device_config *static_alloc_device_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock);
64   virtual device_t *alloc_device(running_machine &machine) const;
65
66   // inline configuration helpers
67   static void static_set_pin7(device_config *device, int pin7);
68
69protected:
70   // device_config_execute_interface overrides
71   virtual UINT32 execute_min_cycles() const;
72   virtual UINT32 execute_max_cycles() const;
73   virtual UINT32 execute_input_lines() const;
74
75   // device_config_memory_interface overrides
76   virtual const address_space_config *memory_space_config(int spacenum = 0) const;
77
78   // device_config_disasm_interface overrides
79   virtual UINT32 disasm_min_opcode_bytes() const;
80   virtual UINT32 disasm_max_opcode_bytes() const;
81
82   // inline data
83   const address_space_config      m_program_config;
84};
85
86
87
88// ======================> asap_device
89
90class asap_device : public cpu_device
91{
92   friend class asap_device_config;
93
94   // construction/destruction
95   asap_device(running_machine &_machine, const asap_device_config &config);
96
97public:
98   // public interfaces
99
100protected:
101   // device-level overrides
102   virtual void device_start();
103   virtual void device_reset();
104
105   // device_execute_interface overrides
106   virtual void execute_run();
107   virtual void execute_set_input(int inputnum, int state);
108
109   // device_state_interface overrides
110   virtual void state_import(const device_state_entry &entry);
111   virtual void state_export(const device_state_entry &entry);
112   virtual void state_string_export(const device_state_entry &entry, astring &string);
113
114   // device_disasm_interface overrides
115   virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
116
117   // helpers
118   inline UINT32 readop(offs_t pc);
119   inline UINT8 readbyte(offs_t address);
120   inline UINT16 readword(offs_t address);
121   inline UINT32 readlong(offs_t address);
122   inline void writebyte(offs_t address, UINT8 data);
123   inline void writeword(offs_t address, UINT16 data);
124   inline void writelong(offs_t address, UINT32 data);
125   inline void generate_exception(int exception);
126   inline void check_irqs();
127   inline void fetch_instruction();
128   inline void fetch_instruction_debug();
129   inline void execute_instruction();
130
131   // condition handlers
132   void bsp();
133   void bmz();
134   void bgt();
135   void ble();
136   void bge();
137   void blt();
138   void bhi();
139   void bls();
140   void bcc();
141   void bcs();
142   void bpl();
143   void bmi();
144   void bne();
145   void beq();
146   void bvc();
147   void bvs();
148
149   // opcode handlers
150   void noop();
151   void trap0();
152   void bsr();
153   void bsr_0();
154   void lea();
155   void lea_c();
156   void lea_c0();
157   void leah();
158   void leah_c();
159   void leah_c0();
160   void subr();
161   void subr_c();
162   void subr_c0();
163   void xor_();
164   void xor_c();
165   void xor_c0();
166   void xorn();
167   void xorn_c();
168   void xorn_c0();
169   void add();
170   void add_c();
171   void add_c0();
172   void sub();
173   void sub_c();
174   void sub_c0();
175   void addc();
176   void addc_c();
177   void addc_c0();
178   void subc();
179   void subc_c();
180   void subc_c0();
181   void and_();
182   void and_c();
183   void and_c0();
184   void andn();
185   void andn_c();
186   void andn_c0();
187   void or_();
188   void or_c();
189   void or_c0();
190   void orn();
191   void orn_c();
192   void orn_c0();
193   void ld();
194   void ld_0();
195   void ld_c();
196   void ld_c0();
197   void ldh();
198   void ldh_0();
199   void ldh_c();
200   void ldh_c0();
201   void lduh();
202   void lduh_0();
203   void lduh_c();
204   void lduh_c0();
205   void sth();
206   void sth_0();
207   void sth_c();
208   void sth_c0();
209   void st();
210   void st_0();
211   void st_c();
212   void st_c0();
213   void ldb();
214   void ldb_0();
215   void ldb_c();
216   void ldb_c0();
217   void ldub();
218   void ldub_0();
219   void ldub_c();
220   void ldub_c0();
221   void stb();
222   void stb_0();
223   void stb_c();
224   void stb_c0();
225   void ashr();
226   void ashr_c();
227   void ashr_c0();
228   void lshr();
229   void lshr_c();
230   void lshr_c0();
231   void ashl();
232   void ashl_c();
233   void ashl_c0();
234   void rotl();
235   void rotl_c();
236   void rotl_c0();
237   void getps();
238   void putps();
239   void jsr();
240   void jsr_0();
241   void jsr_c();
242   void jsr_c0();
243   void trapf();
244
245   // internal state
246   UINT32            m_pc;
247
248   // expanded flags
249   UINT32            m_pflag;
250   UINT32            m_iflag;
251   UINT32            m_cflag;
252   UINT32            m_vflag;
253   UINT32            m_znflag;
254   UINT32            m_flagsio;
255
256   // internal stuff
257   UINT32            m_op;
258   UINT32            m_ppc;
259   UINT32            m_nextpc;
260   UINT8            m_irq_state;
261   int               m_icount;
262   address_space *      m_program;
263   direct_read_data *   m_direct;
264   
265   // src2val table, registers are at the end
266   UINT32            m_src2val[65536];
267   
268   // opcode/condition tables
269   typedef void (asap_device::*ophandler)();
270
271   ophandler         m_opcode[32 * 32 * 2];
272
273   static const ophandler s_opcodetable[32][4];
274   static const ophandler s_conditiontable[16];
275};
276
277
278
279//**************************************************************************
280//  ENUMERATIONS
281//**************************************************************************
282
283// registers
19284enum
20285{
21   ASAP_PC=1,ASAP_PS,
22   ASAP_R0,ASAP_R1,ASAP_R2,ASAP_R3,ASAP_R4,ASAP_R5,ASAP_R6,ASAP_R7,
23   ASAP_R8,ASAP_R9,ASAP_R10,ASAP_R11,ASAP_R12,ASAP_R13,ASAP_R14,ASAP_R15,
24   ASAP_R16,ASAP_R17,ASAP_R18,ASAP_R19,ASAP_R20,ASAP_R21,ASAP_R22,ASAP_R23,
25   ASAP_R24,ASAP_R25,ASAP_R26,ASAP_R27,ASAP_R28,ASAP_R29,ASAP_R30,ASAP_R31
286   ASAP_PC = 1,
287   ASAP_PS,
288   ASAP_R0,
289   ASAP_R1,
290   ASAP_R2,
291   ASAP_R3,
292   ASAP_R4,
293   ASAP_R5,
294   ASAP_R6,
295   ASAP_R7,
296   ASAP_R8,
297   ASAP_R9,
298   ASAP_R10,
299   ASAP_R11,
300   ASAP_R12,
301   ASAP_R13,
302   ASAP_R14,
303   ASAP_R15,
304   ASAP_R16,
305   ASAP_R17,
306   ASAP_R18,
307   ASAP_R19,
308   ASAP_R20,
309   ASAP_R21,
310   ASAP_R22,
311   ASAP_R23,
312   ASAP_R24,
313   ASAP_R25,
314   ASAP_R26,
315   ASAP_R27,
316   ASAP_R28,
317   ASAP_R29,
318   ASAP_R30,
319   ASAP_R31
26320};
27321
322// input lines
323enum
324{
325   ASAP_IRQ0
326};
28327
29/***************************************************************************
30    INTERRUPT CONSTANTS
31***************************************************************************/
32328
33#define ASAP_IRQ0      0      /* IRQ0 */
34329
330// device type definition
331extern const device_type ASAP;
35332
36/***************************************************************************
37    PUBLIC FUNCTIONS
38***************************************************************************/
39333
40DECLARE_LEGACY_CPU_DEVICE(ASAP, asap);
41
42334#endif /* __ASAP_H__ */
src/emu/cpu/asap/asapdasm.c
r9060r9061
4343   return temp;
4444}
4545
46CPU_DISASSEMBLE( asap )
46offs_t asap_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram)
4747{
4848   UINT32 op = oprom[0] | (oprom[1] << 8) | (oprom[2] << 16) | (oprom[3] << 24);
4949   int opcode = op >> 27;
src/emu/distate.c
r9060r9061
410410device_state_interface::device_state_interface(running_machine &machine, const device_config &config, device_t &device)
411411   : device_interface(machine, config, device),
412412     m_machine(machine),
413     m_state_config(dynamic_cast<const device_config_state_interface &>(config)),
414     m_state_list(NULL)
413     m_state_config(dynamic_cast<const device_config_state_interface &>(config))
415414{
416415   memset(m_fast_state, 0, sizeof(m_fast_state));
417416}
r9060r9061
584583   device_state_entry *entry = auto_alloc(&m_machine, device_state_entry(index, symbol, data, size));
585584
586585   // append to the end of the list
587   device_state_entry **tailptr;
588   for (tailptr = &m_state_list; *tailptr != NULL; tailptr = &(*tailptr)->m_next) ;
589   *tailptr = entry;
586   m_state_list.append(*entry);
590587
591588   // set the fast entry if applicable
592589   if (index >= k_fast_state_min && index <= k_fast_state_max)
r9060r9061
608605      return m_fast_state[index - k_fast_state_min];
609606
610607   // otherwise, scan the first
611   for (const device_state_entry *entry = m_state_list; entry != NULL; entry = entry->m_next)
608   for (const device_state_entry *entry = m_state_list.first(); entry != NULL; entry = entry->m_next)
612609      if (entry->m_index == index)
613610         return entry;
614611
r9060r9061
625622void device_state_interface::interface_post_start()
626623{
627624   // make sure we got something during startup
628   if (m_state_list == NULL)
625   if (m_state_list.count() == 0)
629626      throw emu_fatalerror("No state registered for device '%s' that supports it!", m_device.tag());
630627}
src/emu/distate.h
r9060r9061
7373class device_state_entry
7474{
7575   friend class device_state_interface;
76   friend class simple_list<device_state_entry>;
7677
7778private:
7879   // construction/destruction
r9060r9061
161162
162163   // configuration access
163164   const device_config_state_interface &state_config() const { return m_state_config; }
164   const device_state_entry *state_first() const { return m_state_list; }
165   const device_state_entry *state_first() const { return m_state_list.first(); }
165166
166167   // state getters
167168   UINT64 state(int index);
r9060r9061
205206   // state
206207   running_machine &                  m_machine;            // reference to owning machine
207208   const device_config_state_interface &   m_state_config;         // reference to configuration data
208   device_state_entry *               m_state_list;         // head of state list
209   simple_list<device_state_entry>         m_state_list;         // head of state list
209210   device_state_entry *               m_fast_state[k_fast_state_max  + 1 - k_fast_state_min];
210211                                                   // fast access to common entries
211212};
src/emu/devintrf.c
r9060r9061
164164
165165
166166//-------------------------------------------------
167//  debug_setup_all - tell all the devices to set
168//  up any debugging they need
169//-------------------------------------------------
170
171void device_list::debug_setup_all()
172{
173   // iterate over devices and stop them
174   for (device_t *device = first(); device != NULL; device = device->next())
175      device->debug_setup();
176}
177
178
179//-------------------------------------------------
180167//  reset_all - reset all devices in the list
181168//-------------------------------------------------
182169
r9060r9061
735722   
736723   // if we're debugging, create a device_debug object
737724   if ((m_machine.debug_flags & DEBUG_FLAG_ENABLED) != 0)
725   {
738726      m_debug = auto_alloc(&m_machine, device_debug(*this));
727      debug_setup();
728   }
739729
740730   // register our save states
741731   state_save_register_device_item(this, 0, m_clock);
src/emu/devintrf.h
r9060r9061
199199   void import_config_list(const device_config_list &list, running_machine &machine);
200200
201201   void start_all();
202   void debug_setup_all();
203202   void reset_all();
204203};
205204
src/emu/schedule.c
r9060r9061
187187                  exec->m_cycles_stolen = 0;
188188if (TEMPLOG) printf("Executing %s for %d cycles\n", exec->device().tag(), ran);
189189                  m_executing_device = exec;
190                  *exec->m_icount = exec->m_cycles_running;
190                  *exec->m_icountptr = exec->m_cycles_running;
191191                  if (!call_debugger)
192192                     exec->execute_run();
193193                  else
r9060r9061
198198                  }
199199
200200                  // adjust for any cycles we took back
201                  assert(ran >= *exec->m_icount);
202                  ran -= *exec->m_icount;
201                  assert(ran >= *exec->m_icountptr);
202                  ran -= *exec->m_icountptr;
203203                  assert(ran >= exec->m_cycles_stolen);
204204                  ran -= exec->m_cycles_stolen;
205205                  g_profiler.stop();
src/emu/devcpu.c
r9060r9061
263263   m_inited = true;
264264
265265   // fetch information about the CPU states
266   if (m_state_list == NULL)
266   if (m_state_list.count() == 0)
267267   {
268268      m_using_legacy_state = true;
269269      for (int index = 0; index < MAX_REGS; index++)
r9060r9061
301301   }
302302
303303   // get our icount pointer
304   m_icount = reinterpret_cast<int *>(get_legacy_runtime_ptr(CPUINFO_PTR_INSTRUCTION_COUNTER));
305   assert(m_icount != 0);
306   *m_icount = 0;
304   m_icountptr = reinterpret_cast<int *>(get_legacy_runtime_ptr(CPUINFO_PTR_INSTRUCTION_COUNTER));
305   assert(m_icountptr != 0);
306   *m_icountptr = 0;
307307}
308308
309309
src/emu/diexec.c
r9060r9061
280280     m_iloops(0),
281281     m_partial_frame_timer(NULL),
282282     m_profiler(PROFILER_IDLE),
283     m_icount(NULL),
283     m_icountptr(NULL),
284284     m_cycles_running(0),
285285     m_cycles_stolen(0),
286286     m_suspend(0),
r9060r9061
326326
327327INT32 device_execute_interface::cycles_remaining() const
328328{
329   return executing() ? *m_icount : 0;
329   return executing() ? *m_icountptr : 0;
330330}
331331
332332
r9060r9061
342342      return;
343343
344344   // clamp cycles to the icount and update
345   if (cycles > *m_icount)
346      cycles = *m_icount;
347   *m_icount -= cycles;
345   if (cycles > *m_icountptr)
346      cycles = *m_icountptr;
347   *m_icountptr -= cycles;
348348}
349349
350350
r9060r9061
360360      return;
361361
362362   // aply the delta directly
363   *m_icount += delta;
363   *m_icountptr += delta;
364364}
365365
366366
r9060r9061
377377      return;
378378
379379   // swallow the remaining cycles
380   if (m_icount != NULL)
380   if (m_icountptr != NULL)
381381   {
382      int delta = *m_icount;
382      int delta = *m_icountptr;
383383      m_cycles_stolen += delta;
384384      m_cycles_running -= delta;
385      *m_icount -= delta;
385      *m_icountptr -= delta;
386386   }
387387}
388388
r9060r9061
492492   attotime result = m_localtime;
493493   if (executing())
494494   {
495      assert(m_cycles_running >= *m_icount);
496      int cycles = m_cycles_running - *m_icount;
495      assert(m_cycles_running >= *m_icountptr);
496      int cycles = m_cycles_running - *m_icountptr;
497497      result = attotime_add(result, cycles_to_attotime(cycles));
498498   }
499499   return result;
r9060r9061
509509{
510510   if (executing())
511511   {
512      assert(m_cycles_running >= *m_icount);
513      return m_totalcycles + m_cycles_running - *m_icount;
512      assert(m_cycles_running >= *m_icountptr);
513      return m_totalcycles + m_cycles_running - *m_icountptr;
514514   }
515515   else
516516      return m_totalcycles;
r9060r9061
584584void device_execute_interface::interface_post_start()
585585{
586586   // make sure somebody set us up the icount
587   assert_always(m_icount != NULL, "m_icount never initialized!");
587   assert_always(m_icountptr != NULL, "m_icountptr never initialized!");
588588}
589589
590590
src/emu/diexec.h
r9060r9061
323323
324324   // cycle counting and executing
325325   profile_type         m_profiler;               // profiler tag
326   int *               m_icount;               // pointer to the icount
326   int *               m_icountptr;            // pointer to the icount
327327   int                m_cycles_running;         // number of cycles we are executing
328328   int                  m_cycles_stolen;         // number of cycles we artificially stole
329329

Previous 15994 Revisions Next

© 1998-2018 The MESS Team