← Back to branch summary

~ubuntu-branches/debian/squeeze/stella/squeeze

« back to all changes in this revision

Viewing changes to src/emucore/M6502.m4

  • Committer: Bazaar Package Importer
  • Author(s): Stephen Kitt
  • Date: 2010-07-12 23:49:36 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20100712234936-juawrr3etzhr2qpv
Tags: 3.1.2-1
http://bugs.debian.org/532039
http://bugs.debian.org/461121
http://bugs.debian.org/396058
http://bugs.debian.org/560274
* New maintainer (closes: #532039).
* New upstream version (closes: #461121):
  - includes launcher (closes: #396058).
* Fix the reference to the X Window System in the description (closes:
  #411815).
* Move to main, DFSG-free ROMs are available (see README.Debian).
* Enhance the package description.
* Drop the libslang2-dev dependency (closes: #560274).
* Remove the Encoding entry from stella.desktop.
* Avoid ignoring errors when cleaning.
* Add ${misc:Depends} to the package dependencies.
* Provide a doc-base file to install the documentation using doc-base.
* Switch to debhelper 7 with a simplified rules file.
* Use autotools-dev to provide updated configuration files.
* Update to Standards-Version 3.9.0:
  - Move to menu section Applications/Emulators.
  - Move the homepage declaration.
* Re-write the manpage.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/emucore/M6502.m4
 
1
//============================================================================
 
2
//
 
3
// MM     MM  6666  555555  0000   2222
 
4
// MMMM MMMM 66  66 55     00  00 22  22
 
5
// MM MMM MM 66     55     00  00     22
 
6
// MM  M  MM 66666  55555  00  00  22222  --  "A 6502 Microprocessor Emulator"
 
7
// MM     MM 66  66     55 00  00 22
 
8
// MM     MM 66  66 55  55 00  00 22
 
9
// MM     MM  6666   5555   0000  222222
 
10
//
 
11
// Copyright (c) 1995-2010 by Bradford W. Mott, Stephen Anthony
 
12
// and the Stella Team
 
13
//
 
14
// See the file "License.txt" for information on usage and redistribution of
 
15
// this file, and for a DISCLAIMER OF ALL WARRANTIES.
 
16
//
 
17
// $Id: M6502.m4 2001 2010-04-10 21:37:23Z stephena $
 
18
//============================================================================
 
19
 
 
20
/** 
 
21
  Code and cases to emulate each of the 6502 instructions.
 
22
 
 
23
  Recompile with the following:
 
24
    'm4 M6502.m4 > M6502.ins'
 
25
 
 
26
  @author  Bradford W. Mott
 
27
  @version $Id: M6502.m4 2001 2010-04-10 21:37:23Z stephena $
 
28
*/
 
29
 
 
30
#ifndef NOTSAMEPAGE
 
31
  #define NOTSAMEPAGE(_addr1, _addr2) (((_addr1) ^ (_addr2)) & 0xff00)
 
32
#endif
 
33
 
 
34
define(M6502_IMPLIED, `{
 
35
  peek(PC);
 
36
}')
 
37
 
 
38
define(M6502_IMMEDIATE_READ, `{
 
39
  operand = peek(PC++);
 
40
}')
 
41
 
 
42
define(M6502_ABSOLUTE_READ, `{
 
43
  uInt16 address = peek(PC++);
 
44
  address |= ((uInt16)peek(PC++) << 8);
 
45
  operand = peek(address);
 
46
}')
 
47
 
 
48
define(M6502_ABSOLUTE_WRITE, `{
 
49
  operandAddress = peek(PC++);
 
50
  operandAddress |= ((uInt16)peek(PC++) << 8);
 
51
}')
 
52
 
 
53
define(M6502_ABSOLUTE_READMODIFYWRITE, `{
 
54
  operandAddress = peek(PC++);
 
55
  operandAddress |= ((uInt16)peek(PC++) << 8);
 
56
  operand = peek(operandAddress);
 
57
  poke(operandAddress, operand);
 
58
}')
 
59
 
 
60
define(M6502_ABSOLUTEX_READ, `{
 
61
  uInt16 low = peek(PC++);
 
62
  uInt16 high = ((uInt16)peek(PC++) << 8);
 
63
  operand = peek(high | (uInt8)(low + X));
 
64
  if((low + X) > 0xFF)
 
65
    operand = peek((high | low) + X);
 
66
}')
 
67
 
 
68
define(M6502_ABSOLUTEX_WRITE, `{
 
69
  uInt16 low = peek(PC++);
 
70
  uInt16 high = ((uInt16)peek(PC++) << 8);
 
71
  peek(high | (uInt8)(low + X));
 
72
  operandAddress = (high | low) + X;
 
73
}')
 
74
 
 
75
define(M6502_ABSOLUTEX_READMODIFYWRITE, `{
 
76
  uInt16 low = peek(PC++);
 
77
  uInt16 high = ((uInt16)peek(PC++) << 8);
 
78
  peek(high | (uInt8)(low + X));
 
79
  operandAddress = (high | low) + X;
 
80
  operand = peek(operandAddress);
 
81
  poke(operandAddress, operand);
 
82
}')
 
83
 
 
84
define(M6502_ABSOLUTEY_READ, `{
 
85
  uInt16 low = peek(PC++);
 
86
  uInt16 high = ((uInt16)peek(PC++) << 8);
 
87
  operand = peek(high | (uInt8)(low + Y));
 
88
  if((low + Y) > 0xFF)
 
89
    operand = peek((high | low) + Y);
 
90
}')
 
91
 
 
92
define(M6502_ABSOLUTEY_WRITE, `{
 
93
  uInt16 low = peek(PC++);
 
94
  uInt16 high = ((uInt16)peek(PC++) << 8);
 
95
  peek(high | (uInt8)(low + Y));
 
96
  operandAddress = (high | low) + Y;
 
97
}')
 
98
 
 
99
define(M6502_ABSOLUTEY_READMODIFYWRITE, `{
 
100
  uInt16 low = peek(PC++);
 
101
  uInt16 high = ((uInt16)peek(PC++) << 8);
 
102
  peek(high | (uInt8)(low + Y));
 
103
  operandAddress = (high | low) + Y;
 
104
  operand = peek(operandAddress);
 
105
  poke(operandAddress, operand);
 
106
}')
 
107
 
 
108
define(M6502_ZERO_READ, `{
 
109
  operand = peek(peek(PC++));
 
110
}')
 
111
 
 
112
define(M6502_ZERO_WRITE, `{
 
113
  operandAddress = peek(PC++);
 
114
}')
 
115
 
 
116
define(M6502_ZERO_READMODIFYWRITE, `{
 
117
  operandAddress = peek(PC++);
 
118
  operand = peek(operandAddress);
 
119
  poke(operandAddress, operand);
 
120
}')
 
121
 
 
122
define(M6502_ZEROX_READ, `{
 
123
  uInt8 address = peek(PC++);
 
124
  peek(address);
 
125
  address += X;
 
126
  operand = peek(address); 
 
127
}')
 
128
 
 
129
define(M6502_ZEROX_WRITE, `{
 
130
  operandAddress = peek(PC++);
 
131
  peek(operandAddress);
 
132
  operandAddress = (operandAddress + X) & 0xFF;
 
133
}')
 
134
 
 
135
define(M6502_ZEROX_READMODIFYWRITE, `{
 
136
  operandAddress = peek(PC++);
 
137
  peek(operandAddress);
 
138
  operandAddress = (operandAddress + X) & 0xFF;
 
139
  operand = peek(operandAddress);
 
140
  poke(operandAddress, operand);
 
141
}')
 
142
 
 
143
define(M6502_ZEROY_READ, `{
 
144
  uInt8 address = peek(PC++);
 
145
  peek(address);
 
146
  address += Y;
 
147
  operand = peek(address); 
 
148
}')
 
149
 
 
150
define(M6502_ZEROY_WRITE, `{
 
151
  operandAddress = peek(PC++);
 
152
  peek(operandAddress);
 
153
  operandAddress = (operandAddress + Y) & 0xFF;
 
154
}')
 
155
 
 
156
define(M6502_ZEROY_READMODIFYWRITE, `{
 
157
  operandAddress = peek(PC++);
 
158
  peek(operandAddress);
 
159
  operandAddress = (operandAddress + Y) & 0xFF;
 
160
  operand = peek(operandAddress);
 
161
  poke(operandAddress, operand);
 
162
}')
 
163
 
 
164
define(M6502_INDIRECT, `{
 
165
  uInt16 addr = peek(PC++);
 
166
  addr |= ((uInt16)peek(PC++) << 8);
 
167
 
 
168
  // Simulate the error in the indirect addressing mode!
 
169
  uInt16 high = NOTSAMEPAGE(addr, addr + 1) ? (addr & 0xff00) : (addr + 1);
 
170
 
 
171
  operandAddress = peek(addr);
 
172
  operandAddress |= ((uInt16)peek(high) << 8);
 
173
}')
 
174
 
 
175
define(M6502_INDIRECTX_READ, `{
 
176
  uInt8 pointer = peek(PC++);
 
177
  peek(pointer);
 
178
  pointer += X;
 
179
  uInt16 address = peek(pointer++);
 
180
  address |= ((uInt16)peek(pointer) << 8);
 
181
  operand = peek(address);
 
182
}')
 
183
 
 
184
define(M6502_INDIRECTX_WRITE, `{
 
185
  uInt8 pointer = peek(PC++);
 
186
  peek(pointer);
 
187
  pointer += X;
 
188
  operandAddress = peek(pointer++);
 
189
  operandAddress |= ((uInt16)peek(pointer) << 8);
 
190
}')
 
191
 
 
192
define(M6502_INDIRECTX_READMODIFYWRITE, `{
 
193
  uInt8 pointer = peek(PC++);
 
194
  peek(pointer);
 
195
  pointer += X;
 
196
  operandAddress = peek(pointer++);
 
197
  operandAddress |= ((uInt16)peek(pointer) << 8);
 
198
  operand = peek(operandAddress);
 
199
  poke(operandAddress, operand);
 
200
}')
 
201
 
 
202
define(M6502_INDIRECTY_READ, `{
 
203
  uInt8 pointer = peek(PC++);
 
204
  uInt16 low = peek(pointer++);
 
205
  uInt16 high = ((uInt16)peek(pointer) << 8);
 
206
  operand = peek(high | (uInt8)(low + Y));
 
207
  if((low + Y) > 0xFF)
 
208
    operand = peek((high | low) + Y);
 
209
}')
 
210
 
 
211
define(M6502_INDIRECTY_WRITE, `{
 
212
  uInt8 pointer = peek(PC++);
 
213
  uInt16 low = peek(pointer++);
 
214
  uInt16 high = ((uInt16)peek(pointer) << 8);
 
215
  peek(high | (uInt8)(low + Y));
 
216
  operandAddress = (high | low) + Y;
 
217
}')
 
218
 
 
219
define(M6502_INDIRECTY_READMODIFYWRITE, `{
 
220
  uInt8 pointer = peek(PC++);
 
221
  uInt16 low = peek(pointer++);
 
222
  uInt16 high = ((uInt16)peek(pointer) << 8);
 
223
  peek(high | (uInt8)(low + Y));
 
224
  operandAddress = (high | low) + Y;
 
225
  operand = peek(operandAddress);
 
226
  poke(operandAddress, operand);
 
227
}')
 
228
 
 
229
 
 
230
define(M6502_BCC, `{
 
231
  if(!C)
 
232
  {
 
233
    peek(PC);
 
234
    uInt16 address = PC + (Int8)operand;
 
235
    if(NOTSAMEPAGE(PC, address))
 
236
      peek((PC & 0xFF00) | (address & 0x00FF));
 
237
    PC = address;
 
238
  }
 
239
}')
 
240
 
 
241
define(M6502_BCS, `{
 
242
  if(C)
 
243
  {
 
244
    peek(PC);
 
245
    uInt16 address = PC + (Int8)operand;
 
246
    if(NOTSAMEPAGE(PC, address))
 
247
      peek((PC & 0xFF00) | (address & 0x00FF));
 
248
    PC = address;
 
249
  }
 
250
}')
 
251
 
 
252
define(M6502_BEQ, `{
 
253
  if(!notZ)
 
254
  {
 
255
    peek(PC);
 
256
    uInt16 address = PC + (Int8)operand;
 
257
    if(NOTSAMEPAGE(PC, address))
 
258
      peek((PC & 0xFF00) | (address & 0x00FF));
 
259
    PC = address;
 
260
  }
 
261
}')
 
262
 
 
263
define(M6502_BMI, `{
 
264
  if(N)
 
265
  {
 
266
    peek(PC);
 
267
    uInt16 address = PC + (Int8)operand;
 
268
    if(NOTSAMEPAGE(PC, address))
 
269
      peek((PC & 0xFF00) | (address & 0x00FF));
 
270
    PC = address;
 
271
  }
 
272
}')
 
273
 
 
274
define(M6502_BNE, `{
 
275
  if(notZ)
 
276
  {
 
277
    peek(PC);
 
278
    uInt16 address = PC + (Int8)operand;
 
279
    if(NOTSAMEPAGE(PC, address))
 
280
      peek((PC & 0xFF00) | (address & 0x00FF));
 
281
    PC = address;
 
282
  }
 
283
}')
 
284
 
 
285
define(M6502_BPL, `{
 
286
  if(!N)
 
287
  {
 
288
    peek(PC);
 
289
    uInt16 address = PC + (Int8)operand;
 
290
    if(NOTSAMEPAGE(PC, address))
 
291
      peek((PC & 0xFF00) | (address & 0x00FF));
 
292
    PC = address;
 
293
  }
 
294
}')
 
295
 
 
296
define(M6502_BVC, `{
 
297
  if(!V)
 
298
  {
 
299
    peek(PC);
 
300
    uInt16 address = PC + (Int8)operand;
 
301
    if(NOTSAMEPAGE(PC, address))
 
302
      peek((PC & 0xFF00) | (address & 0x00FF));
 
303
    PC = address;
 
304
  }
 
305
}')
 
306
 
 
307
define(M6502_BVS, `{
 
308
  if(V)
 
309
  {
 
310
    peek(PC);
 
311
    uInt16 address = PC + (Int8)operand;
 
312
    if(NOTSAMEPAGE(PC, address))
 
313
      peek((PC & 0xFF00) | (address & 0x00FF));
 
314
    PC = address;
 
315
  }
 
316
}')
 
317
 
 
318
define(M6502_ADC, `{
 
319
  if(!D)
 
320
  {
 
321
    Int32 sum = A + operand + (C ? 1 : 0);
 
322
    N = sum & 0x80;
 
323
    V = ~(A ^ operand) & (A ^ sum) & 0x80;
 
324
    notZ = sum & 0xff;
 
325
    C = sum & 0xff00;
 
326
 
 
327
    A = (uInt8) sum;
 
328
  }
 
329
  else
 
330
  {
 
331
    Int32 lo = (A & 0x0f) + (operand & 0x0f) + (C ? 1 : 0);
 
332
    Int32 hi = (A & 0xf0) + (operand & 0xf0);
 
333
    notZ = (lo+hi) & 0xff;
 
334
    if(lo > 0x09)
 
335
    {
 
336
      hi += 0x10;
 
337
      lo += 0x06;
 
338
    }
 
339
    N = hi & 0x80;
 
340
    V = ~(A ^ operand) & (A ^ hi) & 0x80;
 
341
    if(hi > 0x90)
 
342
      hi += 0x60;
 
343
    C = hi & 0xff00;
 
344
 
 
345
    A = (lo & 0x0f) + (hi & 0xf0);
 
346
  }
 
347
}')
 
348
 
 
349
define(M6502_ANC, `{
 
350
  A &= operand;
 
351
  notZ = A;
 
352
  N = A & 0x80;
 
353
  C = N;
 
354
}')
 
355
 
 
356
define(M6502_AND, `{
 
357
  A &= operand;
 
358
  notZ = A;
 
359
  N = A & 0x80;
 
360
}')
 
361
 
 
362
define(M6502_ANE, `{
 
363
  // NOTE: The implementation of this instruction is based on
 
364
  // information from the 64doc.txt file.  This instruction is
 
365
  // reported to be unstable!
 
366
  A = (A | 0xee) & X & operand;
 
367
  notZ = A;
 
368
  N = A & 0x80;
 
369
}')
 
370
 
 
371
define(M6502_ARR, `{
 
372
  // NOTE: The implementation of this instruction is based on
 
373
  // information from the 64doc.txt file.  There are mixed
 
374
  // reports on its operation!
 
375
  if(!D)
 
376
  {
 
377
    A &= operand;
 
378
    A = ((A >> 1) & 0x7f) | (C ? 0x80 : 0x00);
 
379
 
 
380
    C = A & 0x40;
 
381
    V = (A & 0x40) ^ ((A & 0x20) << 1);
 
382
 
 
383
    notZ = A;
 
384
    N = A & 0x80;
 
385
  }
 
386
  else
 
387
  {
 
388
    uInt8 value = A & operand;
 
389
 
 
390
    A = ((value >> 1) & 0x7f) | (C ? 0x80 : 0x00);
 
391
    N = C;
 
392
    notZ = A;
 
393
    V = (value ^ A) & 0x40;
 
394
 
 
395
    if(((value & 0x0f) + (value & 0x01)) > 0x05)
 
396
    {
 
397
      A = (A & 0xf0) | ((A + 0x06) & 0x0f);
 
398
    }
 
399
    
 
400
    if(((value & 0xf0) + (value & 0x10)) > 0x50) 
 
401
    {
 
402
      A = (A + 0x60) & 0xff;
 
403
      C = 1;
 
404
    }
 
405
    else
 
406
    {
 
407
      C = 0;
 
408
    }
 
409
  }
 
410
}')
 
411
 
 
412
define(M6502_ASL, `{
 
413
  // Set carry flag according to the left-most bit in value
 
414
  C = operand & 0x80;
 
415
 
 
416
  operand <<= 1;
 
417
  poke(operandAddress, operand);
 
418
 
 
419
  notZ = operand;
 
420
  N = operand & 0x80;
 
421
}')
 
422
 
 
423
define(M6502_ASLA, `{
 
424
  // Set carry flag according to the left-most bit in A
 
425
  C = A & 0x80;
 
426
 
 
427
  A <<= 1;
 
428
 
 
429
  notZ = A;
 
430
  N = A & 0x80;
 
431
}')
 
432
 
 
433
define(M6502_ASR, `{
 
434
  A &= operand;
 
435
 
 
436
  // Set carry flag according to the right-most bit
 
437
  C = A & 0x01;
 
438
 
 
439
  A = (A >> 1) & 0x7f;
 
440
 
 
441
  notZ = A;
 
442
  N = A & 0x80;
 
443
}')
 
444
 
 
445
define(M6502_BIT, `{
 
446
  notZ = (A & operand);
 
447
  N = operand & 0x80;
 
448
  V = operand & 0x40;
 
449
}')
 
450
 
 
451
define(M6502_BRK, `{
 
452
  peek(PC++);
 
453
 
 
454
  B = true;
 
455
 
 
456
  poke(0x0100 + SP--, PC >> 8);
 
457
  poke(0x0100 + SP--, PC & 0x00ff);
 
458
  poke(0x0100 + SP--, PS());
 
459
 
 
460
  I = true;
 
461
 
 
462
  PC = peek(0xfffe);
 
463
  PC |= ((uInt16)peek(0xffff) << 8);
 
464
}')
 
465
 
 
466
define(M6502_CLC, `{
 
467
  C = false;
 
468
}')
 
469
 
 
470
define(M6502_CLD, `{
 
471
  D = false;
 
472
}')
 
473
 
 
474
define(M6502_CLI, `{
 
475
  I = false;
 
476
}')
 
477
 
 
478
define(M6502_CLV, `{
 
479
  V = false;
 
480
}')
 
481
 
 
482
define(M6502_CMP, `{
 
483
  uInt16 value = (uInt16)A - (uInt16)operand;
 
484
 
 
485
  notZ = value;
 
486
  N = value & 0x0080;
 
487
  C = !(value & 0x0100);
 
488
}')
 
489
 
 
490
define(M6502_CPX, `{
 
491
  uInt16 value = (uInt16)X - (uInt16)operand;
 
492
 
 
493
  notZ = value;
 
494
  N = value & 0x0080;
 
495
  C = !(value & 0x0100);
 
496
}')
 
497
 
 
498
define(M6502_CPY, `{
 
499
  uInt16 value = (uInt16)Y - (uInt16)operand;
 
500
 
 
501
  notZ = value;
 
502
  N = value & 0x0080;
 
503
  C = !(value & 0x0100);
 
504
}')
 
505
 
 
506
define(M6502_DCP, `{
 
507
  uInt8 value = operand - 1;
 
508
  poke(operandAddress, value);
 
509
 
 
510
  uInt16 value2 = (uInt16)A - (uInt16)value;
 
511
  notZ = value2;
 
512
  N = value2 & 0x0080;
 
513
  C = !(value2 & 0x0100);
 
514
}')
 
515
 
 
516
define(M6502_DEC, `{
 
517
  uInt8 value = operand - 1;
 
518
  poke(operandAddress, value);
 
519
 
 
520
  notZ = value;
 
521
  N = value & 0x80;
 
522
}')
 
523
 
 
524
define(M6502_DEX, `{
 
525
  X--;
 
526
 
 
527
  notZ = X;
 
528
  N = X & 0x80;
 
529
}')
 
530
 
 
531
 
 
532
define(M6502_DEY, `{
 
533
  Y--;
 
534
 
 
535
  notZ = Y;
 
536
  N = Y & 0x80;
 
537
}')
 
538
 
 
539
define(M6502_EOR, `{
 
540
  A ^= operand;
 
541
  notZ = A;
 
542
  N = A & 0x80;
 
543
}')
 
544
 
 
545
define(M6502_INC, `{
 
546
  uInt8 value = operand + 1;
 
547
  poke(operandAddress, value);
 
548
 
 
549
  notZ = value;
 
550
  N = value & 0x80;
 
551
}')
 
552
 
 
553
define(M6502_INX, `{
 
554
  X++;
 
555
  notZ = X;
 
556
  N = X & 0x80;
 
557
}')
 
558
 
 
559
define(M6502_INY, `{
 
560
  Y++;
 
561
  notZ = Y;
 
562
  N = Y & 0x80;
 
563
}')
 
564
 
 
565
define(M6502_ISB, `{
 
566
  operand = operand + 1;
 
567
  poke(operandAddress, operand);
 
568
 
 
569
  // N, V, Z, C flags are the same in either mode (C calculated at the end)
 
570
  Int32 sum = A - operand - (C ? 0 : 1);
 
571
  N = sum & 0x80;
 
572
  V = (A ^ operand) & (A ^ sum) & 0x80;
 
573
  notZ = sum & 0xff;
 
574
 
 
575
  if(!D)
 
576
  {
 
577
    A = (uInt8) sum;
 
578
  }
 
579
  else
 
580
  {
 
581
    Int32 lo = (A & 0x0f) - (operand & 0x0f) - (C ? 0 : 1);
 
582
    Int32 hi = (A & 0xf0) - (operand & 0xf0);
 
583
    if(lo & 0x10)
 
584
    {
 
585
      lo -= 6;
 
586
      hi--;
 
587
    }
 
588
    if(hi & 0x0100)
 
589
      hi -= 0x60;
 
590
 
 
591
    A = (lo & 0x0f) | (hi & 0xf0);
 
592
  }
 
593
  C = (sum & 0xff00) == 0;
 
594
}')
 
595
 
 
596
define(M6502_JMP, `{
 
597
  PC = operandAddress;
 
598
}')
 
599
 
 
600
define(M6502_JSR, `{
 
601
  uInt8 low = peek(PC++);
 
602
  peek(0x0100 + SP);
 
603
 
 
604
  // It seems that the 650x does not push the address of the next instruction
 
605
  // on the stack it actually pushes the address of the next instruction
 
606
  // minus one.  This is compensated for in the RTS instruction
 
607
  poke(0x0100 + SP--, PC >> 8);
 
608
  poke(0x0100 + SP--, PC & 0xff);
 
609
 
 
610
  PC = low | ((uInt16)peek(PC++) << 8); 
 
611
}')
 
612
 
 
613
define(M6502_LAS, `{
 
614
  A = X = SP = SP & operand;
 
615
  notZ = A;
 
616
  N = A & 0x80;
 
617
}')
 
618
 
 
619
define(M6502_LAX, `{
 
620
  A = operand;
 
621
  X = operand;
 
622
  notZ = A;
 
623
  N = A & 0x80;
 
624
}')
 
625
 
 
626
define(M6502_LDA, `{
 
627
  A = operand;
 
628
  notZ = A;
 
629
  N = A & 0x80;
 
630
}')
 
631
 
 
632
define(M6502_LDX, `{
 
633
  X = operand;
 
634
  notZ = X;
 
635
  N = X & 0x80;
 
636
}')
 
637
 
 
638
define(M6502_LDY, `{
 
639
  Y = operand;
 
640
  notZ = Y;
 
641
  N = Y & 0x80;
 
642
}')
 
643
 
 
644
define(M6502_LSR, `{
 
645
  // Set carry flag according to the right-most bit in value
 
646
  C = operand & 0x01;
 
647
 
 
648
  operand = (operand >> 1) & 0x7f;
 
649
  poke(operandAddress, operand);
 
650
 
 
651
  notZ = operand;
 
652
  N = operand & 0x80;
 
653
}')
 
654
 
 
655
define(M6502_LSRA, `{
 
656
  // Set carry flag according to the right-most bit
 
657
  C = A & 0x01;
 
658
 
 
659
  A = (A >> 1) & 0x7f;
 
660
 
 
661
  notZ = A;
 
662
  N = A & 0x80;
 
663
}')
 
664
 
 
665
define(M6502_LXA, `{
 
666
  // NOTE: The implementation of this instruction is based on
 
667
  // information from the 64doc.txt file.  This instruction is
 
668
  // reported to be very unstable!
 
669
  A = X = (A | 0xee) & operand;
 
670
  notZ = A;
 
671
  N = A & 0x80;
 
672
}')
 
673
 
 
674
define(M6502_NOP, `{
 
675
}')
 
676
 
 
677
define(M6502_ORA, `{
 
678
  A |= operand;
 
679
  notZ = A;
 
680
  N = A & 0x80;
 
681
}')
 
682
 
 
683
define(M6502_PHA, `{
 
684
  poke(0x0100 + SP--, A);
 
685
}')
 
686
 
 
687
define(M6502_PHP, `{
 
688
  poke(0x0100 + SP--, PS());
 
689
}')
 
690
 
 
691
define(M6502_PLA, `{
 
692
  peek(0x0100 + SP++);
 
693
  A = peek(0x0100 + SP);
 
694
  notZ = A;
 
695
  N = A & 0x80;
 
696
}')
 
697
 
 
698
define(M6502_PLP, `{
 
699
  peek(0x0100 + SP++);
 
700
  PS(peek(0x0100 + SP));
 
701
}')
 
702
 
 
703
define(M6502_RLA, `{
 
704
  uInt8 value = (operand << 1) | (C ? 1 : 0);
 
705
  poke(operandAddress, value);
 
706
 
 
707
  A &= value;
 
708
  C = operand & 0x80;
 
709
  notZ = A;
 
710
  N = A & 0x80;
 
711
}')
 
712
 
 
713
define(M6502_ROL, `{
 
714
  bool oldC = C;
 
715
 
 
716
  // Set carry flag according to the left-most bit in operand
 
717
  C = operand & 0x80;
 
718
 
 
719
  operand = (operand << 1) | (oldC ? 1 : 0);
 
720
  poke(operandAddress, operand);
 
721
 
 
722
  notZ = operand;
 
723
  N = operand & 0x80;
 
724
}')
 
725
 
 
726
define(M6502_ROLA, `{
 
727
  bool oldC = C;
 
728
 
 
729
  // Set carry flag according to the left-most bit
 
730
  C = A & 0x80;
 
731
 
 
732
  A = (A << 1) | (oldC ? 1 : 0);
 
733
 
 
734
  notZ = A;
 
735
  N = A & 0x80;
 
736
}')
 
737
 
 
738
define(M6502_ROR, `{
 
739
  bool oldC = C;
 
740
 
 
741
  // Set carry flag according to the right-most bit
 
742
  C = operand & 0x01;
 
743
 
 
744
  operand = ((operand >> 1) & 0x7f) | (oldC ? 0x80 : 0x00);
 
745
  poke(operandAddress, operand);
 
746
 
 
747
  notZ = operand;
 
748
  N = operand & 0x80;
 
749
}')
 
750
 
 
751
define(M6502_RORA, `{
 
752
  bool oldC = C;
 
753
 
 
754
  // Set carry flag according to the right-most bit
 
755
  C = A & 0x01;
 
756
 
 
757
  A = ((A >> 1) & 0x7f) | (oldC ? 0x80 : 0x00);
 
758
 
 
759
  notZ = A;
 
760
  N = A & 0x80;
 
761
}')
 
762
 
 
763
define(M6502_RRA, `{
 
764
  bool oldC = C;
 
765
 
 
766
  // Set carry flag according to the right-most bit
 
767
  C = operand & 0x01;
 
768
 
 
769
  operand = ((operand >> 1) & 0x7f) | (oldC ? 0x80 : 0x00);
 
770
  poke(operandAddress, operand);
 
771
 
 
772
  if(!D)
 
773
  {
 
774
    Int32 sum = A + operand + (C ? 1 : 0);
 
775
    N = sum & 0x80;
 
776
    V = ~(A ^ operand) & (A ^ sum) & 0x80;
 
777
    notZ = sum & 0xff;
 
778
    C = sum & 0xff00;
 
779
 
 
780
    A = (uInt8) sum;
 
781
  }
 
782
  else
 
783
  {
 
784
    Int32 lo = (A & 0x0f) + (operand & 0x0f) + (C ? 1 : 0);
 
785
    Int32 hi = (A & 0xf0) + (operand & 0xf0);
 
786
    notZ = (lo+hi) & 0xff;
 
787
    if(lo > 0x09)
 
788
    {
 
789
      hi += 0x10;
 
790
      lo += 0x06;
 
791
    }
 
792
    N = hi & 0x80;
 
793
    V = ~(A ^ operand) & (A ^ hi) & 0x80;
 
794
    if(hi > 0x90)
 
795
      hi += 0x60;
 
796
    C = hi & 0xff00;
 
797
 
 
798
    A = (lo & 0x0f) + (hi & 0xf0);
 
799
  }
 
800
}')
 
801
 
 
802
define(M6502_RTI, `{
 
803
  peek(0x0100 + SP++);
 
804
  PS(peek(0x0100 + SP++));
 
805
  PC = peek(0x0100 + SP++);
 
806
  PC |= ((uInt16)peek(0x0100 + SP) << 8);
 
807
}')
 
808
 
 
809
define(M6502_RTS, `{
 
810
  peek(0x0100 + SP++);
 
811
  PC = peek(0x0100 + SP++);
 
812
  PC |= ((uInt16)peek(0x0100 + SP) << 8);
 
813
  peek(PC++);
 
814
}')
 
815
 
 
816
define(M6502_SAX, `{
 
817
  poke(operandAddress, A & X);
 
818
}')
 
819
 
 
820
define(M6502_SBC, `{
 
821
  // N, V, Z, C flags are the same in either mode (C calculated at the end)
 
822
  Int32 sum = A - operand - (C ? 0 : 1);
 
823
  N = sum & 0x80;
 
824
  V = (A ^ operand) & (A ^ sum) & 0x80;
 
825
  notZ = sum & 0xff;
 
826
 
 
827
  if(!D)
 
828
  {
 
829
    A = (uInt8) sum;
 
830
  }
 
831
  else
 
832
  {
 
833
    Int32 lo = (A & 0x0f) - (operand & 0x0f) - (C ? 0 : 1);
 
834
    Int32 hi = (A & 0xf0) - (operand & 0xf0);
 
835
    if(lo & 0x10)
 
836
    {
 
837
      lo -= 6;
 
838
      hi--;
 
839
    }
 
840
    if(hi & 0x0100)
 
841
      hi -= 0x60;
 
842
 
 
843
    A = (lo & 0x0f) | (hi & 0xf0);
 
844
  }
 
845
  C = (sum & 0xff00) == 0;
 
846
}')
 
847
 
 
848
define(M6502_SBX, `{
 
849
  uInt16 value = (uInt16)(X & A) - (uInt16)operand;
 
850
  X = (value & 0xff);
 
851
 
 
852
  notZ = X;
 
853
  N = X & 0x80;
 
854
  C = !(value & 0x0100);
 
855
}')
 
856
 
 
857
define(M6502_SEC, `{
 
858
  C = true;
 
859
}')
 
860
 
 
861
define(M6502_SED, `{
 
862
  D = true;
 
863
}')
 
864
 
 
865
define(M6502_SEI, `{
 
866
  I = true;
 
867
}')
 
868
 
 
869
define(M6502_SHA, `{
 
870
  // NOTE: There are mixed reports on the actual operation
 
871
  // of this instruction!
 
872
  poke(operandAddress, A & X & (((operandAddress >> 8) & 0xff) + 1)); 
 
873
}')
 
874
 
 
875
define(M6502_SHS, `{
 
876
  // NOTE: There are mixed reports on the actual operation
 
877
  // of this instruction!
 
878
  SP = A & X;
 
879
  poke(operandAddress, A & X & (((operandAddress >> 8) & 0xff) + 1)); 
 
880
}')
 
881
 
 
882
define(M6502_SHX, `{
 
883
  // NOTE: There are mixed reports on the actual operation
 
884
  // of this instruction!
 
885
  poke(operandAddress, X & (((operandAddress >> 8) & 0xff) + 1)); 
 
886
}')
 
887
 
 
888
define(M6502_SHY, `{
 
889
  // NOTE: There are mixed reports on the actual operation
 
890
  // of this instruction!
 
891
  poke(operandAddress, Y & (((operandAddress >> 8) & 0xff) + 1)); 
 
892
}')
 
893
 
 
894
define(M6502_SLO, `{
 
895
  // Set carry flag according to the left-most bit in value
 
896
  C = operand & 0x80;
 
897
 
 
898
  operand <<= 1;
 
899
  poke(operandAddress, operand);
 
900
 
 
901
  A |= operand;
 
902
  notZ = A;
 
903
  N = A & 0x80;
 
904
}')
 
905
 
 
906
define(M6502_SRE, `{
 
907
  // Set carry flag according to the right-most bit in value
 
908
  C = operand & 0x01;
 
909
 
 
910
  operand = (operand >> 1) & 0x7f;
 
911
  poke(operandAddress, operand);
 
912
 
 
913
  A ^= operand;
 
914
  notZ = A;
 
915
  N = A & 0x80;
 
916
}')
 
917
 
 
918
define(M6502_STA, `{
 
919
  poke(operandAddress, A);
 
920
}')
 
921
 
 
922
define(M6502_STX, `{
 
923
  poke(operandAddress, X);
 
924
}')
 
925
 
 
926
define(M6502_STY, `{
 
927
  poke(operandAddress, Y);
 
928
}')
 
929
 
 
930
define(M6502_TAX, `{
 
931
  X = A;
 
932
  notZ = X;
 
933
  N = X & 0x80;
 
934
}')
 
935
 
 
936
define(M6502_TAY, `{
 
937
  Y = A;
 
938
  notZ = Y;
 
939
  N = Y & 0x80;
 
940
}')
 
941
 
 
942
define(M6502_TSX, `{
 
943
  X = SP;
 
944
  notZ = X;
 
945
  N = X & 0x80;
 
946
}')
 
947
 
 
948
define(M6502_TXA, `{
 
949
  A = X;
 
950
  notZ = A;
 
951
  N = A & 0x80;
 
952
}')
 
953
 
 
954
define(M6502_TXS, `{
 
955
  SP = X;
 
956
}')
 
957
 
 
958
define(M6502_TYA, `{
 
959
  A = Y;
 
960
  notZ = A;
 
961
  N = A & 0x80;
 
962
}')
 
963
 
 
964
 
 
965
case 0x69:
 
966
M6502_IMMEDIATE_READ
 
967
M6502_ADC
 
968
break;
 
969
 
 
970
case 0x65:
 
971
M6502_ZERO_READ
 
972
M6502_ADC
 
973
break;
 
974
 
 
975
case 0x75:
 
976
M6502_ZEROX_READ
 
977
M6502_ADC
 
978
break;
 
979
 
 
980
case 0x6d:
 
981
M6502_ABSOLUTE_READ
 
982
M6502_ADC
 
983
break;
 
984
 
 
985
case 0x7d:
 
986
M6502_ABSOLUTEX_READ
 
987
M6502_ADC
 
988
break;
 
989
 
 
990
case 0x79:
 
991
M6502_ABSOLUTEY_READ
 
992
M6502_ADC
 
993
break;
 
994
 
 
995
case 0x61:
 
996
M6502_INDIRECTX_READ
 
997
M6502_ADC
 
998
break;
 
999
 
 
1000
case 0x71:
 
1001
M6502_INDIRECTY_READ
 
1002
M6502_ADC
 
1003
break;
 
1004
 
 
1005
 
 
1006
case 0x4b:
 
1007
M6502_IMMEDIATE_READ
 
1008
M6502_ASR
 
1009
break;
 
1010
 
 
1011
 
 
1012
case 0x0b:
 
1013
case 0x2b:
 
1014
M6502_IMMEDIATE_READ
 
1015
M6502_ANC
 
1016
break;
 
1017
 
 
1018
 
 
1019
case 0x29:
 
1020
M6502_IMMEDIATE_READ
 
1021
M6502_AND
 
1022
break;
 
1023
 
 
1024
case 0x25:
 
1025
M6502_ZERO_READ
 
1026
M6502_AND
 
1027
break;
 
1028
 
 
1029
case 0x35:
 
1030
M6502_ZEROX_READ
 
1031
M6502_AND
 
1032
break;
 
1033
 
 
1034
case 0x2d:
 
1035
M6502_ABSOLUTE_READ
 
1036
M6502_AND
 
1037
break;
 
1038
 
 
1039
case 0x3d:
 
1040
M6502_ABSOLUTEX_READ
 
1041
M6502_AND
 
1042
break;
 
1043
 
 
1044
case 0x39:
 
1045
M6502_ABSOLUTEY_READ
 
1046
M6502_AND
 
1047
break;
 
1048
 
 
1049
case 0x21:
 
1050
M6502_INDIRECTX_READ
 
1051
M6502_AND
 
1052
break;
 
1053
 
 
1054
case 0x31:
 
1055
M6502_INDIRECTY_READ
 
1056
M6502_AND
 
1057
break;
 
1058
 
 
1059
 
 
1060
case 0x8b:
 
1061
M6502_IMMEDIATE_READ
 
1062
M6502_ANE
 
1063
break;
 
1064
 
 
1065
 
 
1066
case 0x6b:
 
1067
M6502_IMMEDIATE_READ
 
1068
M6502_ARR
 
1069
break;
 
1070
 
 
1071
 
 
1072
case 0x0a:
 
1073
M6502_IMPLIED
 
1074
M6502_ASLA
 
1075
break;
 
1076
 
 
1077
case 0x06:
 
1078
M6502_ZERO_READMODIFYWRITE
 
1079
M6502_ASL
 
1080
break;
 
1081
 
 
1082
case 0x16:
 
1083
M6502_ZEROX_READMODIFYWRITE
 
1084
M6502_ASL
 
1085
break;
 
1086
 
 
1087
case 0x0e:
 
1088
M6502_ABSOLUTE_READMODIFYWRITE
 
1089
M6502_ASL
 
1090
break;
 
1091
 
 
1092
case 0x1e:
 
1093
M6502_ABSOLUTEX_READMODIFYWRITE
 
1094
M6502_ASL
 
1095
break;
 
1096
 
 
1097
 
 
1098
case 0x90:
 
1099
M6502_IMMEDIATE_READ
 
1100
M6502_BCC
 
1101
break;
 
1102
 
 
1103
 
 
1104
case 0xb0:
 
1105
M6502_IMMEDIATE_READ
 
1106
M6502_BCS
 
1107
break;
 
1108
 
 
1109
 
 
1110
case 0xf0:
 
1111
M6502_IMMEDIATE_READ
 
1112
M6502_BEQ
 
1113
break;
 
1114
 
 
1115
 
 
1116
case 0x24:
 
1117
M6502_ZERO_READ
 
1118
M6502_BIT
 
1119
break;
 
1120
 
 
1121
case 0x2C:
 
1122
M6502_ABSOLUTE_READ
 
1123
M6502_BIT
 
1124
break;
 
1125
 
 
1126
 
 
1127
case 0x30:
 
1128
M6502_IMMEDIATE_READ
 
1129
M6502_BMI
 
1130
break;
 
1131
 
 
1132
 
 
1133
case 0xD0:
 
1134
M6502_IMMEDIATE_READ
 
1135
M6502_BNE
 
1136
break;
 
1137
 
 
1138
 
 
1139
case 0x10:
 
1140
M6502_IMMEDIATE_READ
 
1141
M6502_BPL
 
1142
break;
 
1143
 
 
1144
 
 
1145
case 0x00:
 
1146
M6502_BRK
 
1147
break;
 
1148
 
 
1149
 
 
1150
case 0x50:
 
1151
M6502_IMMEDIATE_READ
 
1152
M6502_BVC
 
1153
break;
 
1154
 
 
1155
 
 
1156
case 0x70:
 
1157
M6502_IMMEDIATE_READ
 
1158
M6502_BVS
 
1159
break;
 
1160
 
 
1161
 
 
1162
case 0x18:
 
1163
M6502_IMPLIED
 
1164
M6502_CLC
 
1165
break;
 
1166
 
 
1167
 
 
1168
case 0xd8:
 
1169
M6502_IMPLIED
 
1170
M6502_CLD
 
1171
break;
 
1172
 
 
1173
 
 
1174
case 0x58:
 
1175
M6502_IMPLIED
 
1176
M6502_CLI
 
1177
break;
 
1178
 
 
1179
 
 
1180
case 0xb8:
 
1181
M6502_IMPLIED
 
1182
M6502_CLV
 
1183
break;
 
1184
 
 
1185
 
 
1186
case 0xc9:
 
1187
M6502_IMMEDIATE_READ
 
1188
M6502_CMP
 
1189
break;
 
1190
 
 
1191
case 0xc5:
 
1192
M6502_ZERO_READ
 
1193
M6502_CMP
 
1194
break;
 
1195
 
 
1196
case 0xd5:
 
1197
M6502_ZEROX_READ
 
1198
M6502_CMP
 
1199
break;
 
1200
 
 
1201
case 0xcd:
 
1202
M6502_ABSOLUTE_READ
 
1203
M6502_CMP
 
1204
break;
 
1205
 
 
1206
case 0xdd:
 
1207
M6502_ABSOLUTEX_READ
 
1208
M6502_CMP
 
1209
break;
 
1210
 
 
1211
case 0xd9:
 
1212
M6502_ABSOLUTEY_READ
 
1213
M6502_CMP
 
1214
break;
 
1215
 
 
1216
case 0xc1:
 
1217
M6502_INDIRECTX_READ
 
1218
M6502_CMP
 
1219
break;
 
1220
 
 
1221
case 0xd1:
 
1222
M6502_INDIRECTY_READ
 
1223
M6502_CMP
 
1224
break;
 
1225
 
 
1226
 
 
1227
case 0xe0:
 
1228
M6502_IMMEDIATE_READ
 
1229
M6502_CPX
 
1230
break;
 
1231
 
 
1232
case 0xe4:
 
1233
M6502_ZERO_READ
 
1234
M6502_CPX
 
1235
break;
 
1236
 
 
1237
case 0xec:
 
1238
M6502_ABSOLUTE_READ
 
1239
M6502_CPX
 
1240
break;
 
1241
 
 
1242
 
 
1243
case 0xc0:
 
1244
M6502_IMMEDIATE_READ
 
1245
M6502_CPY
 
1246
break;
 
1247
 
 
1248
case 0xc4:
 
1249
M6502_ZERO_READ
 
1250
M6502_CPY
 
1251
break;
 
1252
 
 
1253
case 0xcc:
 
1254
M6502_ABSOLUTE_READ
 
1255
M6502_CPY
 
1256
break;
 
1257
 
 
1258
 
 
1259
case 0xcf:
 
1260
M6502_ABSOLUTE_READMODIFYWRITE
 
1261
M6502_DCP
 
1262
break;
 
1263
 
 
1264
case 0xdf:
 
1265
M6502_ABSOLUTEX_READMODIFYWRITE
 
1266
M6502_DCP
 
1267
break;
 
1268
 
 
1269
case 0xdb:
 
1270
M6502_ABSOLUTEY_READMODIFYWRITE
 
1271
M6502_DCP
 
1272
break;
 
1273
 
 
1274
case 0xc7:
 
1275
M6502_ZERO_READMODIFYWRITE
 
1276
M6502_DCP
 
1277
break;
 
1278
 
 
1279
case 0xd7:
 
1280
M6502_ZEROX_READMODIFYWRITE
 
1281
M6502_DCP
 
1282
break;
 
1283
 
 
1284
case 0xc3:
 
1285
M6502_INDIRECTX_READMODIFYWRITE
 
1286
M6502_DCP
 
1287
break;
 
1288
 
 
1289
case 0xd3:
 
1290
M6502_INDIRECTY_READMODIFYWRITE
 
1291
M6502_DCP
 
1292
break;
 
1293
 
 
1294
 
 
1295
case 0xc6:
 
1296
M6502_ZERO_READMODIFYWRITE
 
1297
M6502_DEC
 
1298
break;
 
1299
 
 
1300
case 0xd6:
 
1301
M6502_ZEROX_READMODIFYWRITE
 
1302
M6502_DEC
 
1303
break;
 
1304
 
 
1305
case 0xce:
 
1306
M6502_ABSOLUTE_READMODIFYWRITE
 
1307
M6502_DEC
 
1308
break;
 
1309
 
 
1310
case 0xde:
 
1311
M6502_ABSOLUTEX_READMODIFYWRITE
 
1312
M6502_DEC
 
1313
break;
 
1314
 
 
1315
 
 
1316
case 0xca:
 
1317
M6502_IMPLIED
 
1318
M6502_DEX
 
1319
break;
 
1320
 
 
1321
 
 
1322
case 0x88:
 
1323
M6502_IMPLIED
 
1324
M6502_DEY
 
1325
break;
 
1326
 
 
1327
 
 
1328
case 0x49:
 
1329
M6502_IMMEDIATE_READ
 
1330
M6502_EOR
 
1331
break;
 
1332
 
 
1333
case 0x45:
 
1334
M6502_ZERO_READ
 
1335
M6502_EOR
 
1336
break;
 
1337
 
 
1338
case 0x55:
 
1339
M6502_ZEROX_READ
 
1340
M6502_EOR
 
1341
break;
 
1342
 
 
1343
case 0x4d:
 
1344
M6502_ABSOLUTE_READ
 
1345
M6502_EOR
 
1346
break;
 
1347
 
 
1348
case 0x5d:
 
1349
M6502_ABSOLUTEX_READ
 
1350
M6502_EOR
 
1351
break;
 
1352
 
 
1353
case 0x59:
 
1354
M6502_ABSOLUTEY_READ
 
1355
M6502_EOR
 
1356
break;
 
1357
 
 
1358
case 0x41:
 
1359
M6502_INDIRECTX_READ
 
1360
M6502_EOR
 
1361
break;
 
1362
 
 
1363
case 0x51:
 
1364
M6502_INDIRECTY_READ
 
1365
M6502_EOR
 
1366
break;
 
1367
 
 
1368
 
 
1369
case 0xe6:
 
1370
M6502_ZERO_READMODIFYWRITE
 
1371
M6502_INC
 
1372
break;
 
1373
 
 
1374
case 0xf6:
 
1375
M6502_ZEROX_READMODIFYWRITE
 
1376
M6502_INC
 
1377
break;
 
1378
 
 
1379
case 0xee:
 
1380
M6502_ABSOLUTE_READMODIFYWRITE
 
1381
M6502_INC
 
1382
break;
 
1383
 
 
1384
case 0xfe:
 
1385
M6502_ABSOLUTEX_READMODIFYWRITE
 
1386
M6502_INC
 
1387
break;
 
1388
 
 
1389
 
 
1390
case 0xe8:
 
1391
M6502_IMPLIED
 
1392
M6502_INX
 
1393
break;
 
1394
 
 
1395
 
 
1396
case 0xc8:
 
1397
M6502_IMPLIED
 
1398
M6502_INY
 
1399
break;
 
1400
 
 
1401
 
 
1402
case 0xef:
 
1403
M6502_ABSOLUTE_READMODIFYWRITE
 
1404
M6502_ISB
 
1405
break;
 
1406
 
 
1407
case 0xff:
 
1408
M6502_ABSOLUTEX_READMODIFYWRITE
 
1409
M6502_ISB
 
1410
break;
 
1411
 
 
1412
case 0xfb:
 
1413
M6502_ABSOLUTEY_READMODIFYWRITE
 
1414
M6502_ISB
 
1415
break;
 
1416
 
 
1417
case 0xe7:
 
1418
M6502_ZERO_READMODIFYWRITE
 
1419
M6502_ISB
 
1420
break;
 
1421
 
 
1422
case 0xf7:
 
1423
M6502_ZEROX_READMODIFYWRITE
 
1424
M6502_ISB
 
1425
break;
 
1426
 
 
1427
case 0xe3:
 
1428
M6502_INDIRECTX_READMODIFYWRITE
 
1429
M6502_ISB
 
1430
break;
 
1431
 
 
1432
case 0xf3:
 
1433
M6502_INDIRECTY_READMODIFYWRITE
 
1434
M6502_ISB
 
1435
break;
 
1436
 
 
1437
 
 
1438
case 0x4c:
 
1439
M6502_ABSOLUTE_WRITE
 
1440
M6502_JMP
 
1441
break;
 
1442
 
 
1443
case 0x6c:
 
1444
M6502_INDIRECT
 
1445
M6502_JMP
 
1446
break;
 
1447
 
 
1448
 
 
1449
case 0x20:
 
1450
M6502_JSR
 
1451
break;
 
1452
 
 
1453
 
 
1454
case 0xbb:
 
1455
M6502_ABSOLUTEY_READ
 
1456
M6502_LAS
 
1457
break;
 
1458
 
 
1459
 
 
1460
case 0xaf:
 
1461
M6502_ABSOLUTE_READ
 
1462
M6502_LAX
 
1463
break;
 
1464
 
 
1465
case 0xbf:
 
1466
M6502_ABSOLUTEY_READ
 
1467
M6502_LAX
 
1468
break;
 
1469
 
 
1470
case 0xa7:
 
1471
M6502_ZERO_READ
 
1472
M6502_LAX
 
1473
break;
 
1474
 
 
1475
case 0xb7:
 
1476
M6502_ZEROY_READ
 
1477
M6502_LAX
 
1478
break;
 
1479
 
 
1480
case 0xa3:
 
1481
M6502_INDIRECTX_READ
 
1482
M6502_LAX
 
1483
break;
 
1484
 
 
1485
case 0xb3:
 
1486
M6502_INDIRECTY_READ
 
1487
M6502_LAX
 
1488
break;
 
1489
 
 
1490
 
 
1491
case 0xa9:
 
1492
M6502_IMMEDIATE_READ
 
1493
M6502_LDA
 
1494
break;
 
1495
 
 
1496
case 0xa5:
 
1497
M6502_ZERO_READ
 
1498
M6502_LDA
 
1499
break;
 
1500
 
 
1501
case 0xb5:
 
1502
M6502_ZEROX_READ
 
1503
M6502_LDA
 
1504
break;
 
1505
 
 
1506
case 0xad:
 
1507
M6502_ABSOLUTE_READ
 
1508
M6502_LDA
 
1509
break;
 
1510
 
 
1511
case 0xbd:
 
1512
M6502_ABSOLUTEX_READ
 
1513
M6502_LDA
 
1514
break;
 
1515
 
 
1516
case 0xb9:
 
1517
M6502_ABSOLUTEY_READ
 
1518
M6502_LDA
 
1519
break;
 
1520
 
 
1521
case 0xa1:
 
1522
M6502_INDIRECTX_READ
 
1523
M6502_LDA
 
1524
break;
 
1525
 
 
1526
case 0xb1:
 
1527
M6502_INDIRECTY_READ
 
1528
M6502_LDA
 
1529
break;
 
1530
 
 
1531
 
 
1532
case 0xa2:
 
1533
M6502_IMMEDIATE_READ
 
1534
M6502_LDX
 
1535
break;
 
1536
 
 
1537
case 0xa6:
 
1538
M6502_ZERO_READ
 
1539
M6502_LDX
 
1540
break;
 
1541
 
 
1542
case 0xb6:
 
1543
M6502_ZEROY_READ
 
1544
M6502_LDX
 
1545
break;
 
1546
 
 
1547
case 0xae:
 
1548
M6502_ABSOLUTE_READ
 
1549
M6502_LDX
 
1550
break;
 
1551
 
 
1552
case 0xbe:
 
1553
M6502_ABSOLUTEY_READ
 
1554
M6502_LDX
 
1555
break;
 
1556
 
 
1557
 
 
1558
case 0xa0:
 
1559
M6502_IMMEDIATE_READ
 
1560
M6502_LDY
 
1561
break;
 
1562
 
 
1563
case 0xa4:
 
1564
M6502_ZERO_READ
 
1565
M6502_LDY
 
1566
break;
 
1567
 
 
1568
case 0xb4:
 
1569
M6502_ZEROX_READ
 
1570
M6502_LDY
 
1571
break;
 
1572
 
 
1573
case 0xac:
 
1574
M6502_ABSOLUTE_READ
 
1575
M6502_LDY
 
1576
break;
 
1577
 
 
1578
case 0xbc:
 
1579
M6502_ABSOLUTEX_READ
 
1580
M6502_LDY
 
1581
break;
 
1582
 
 
1583
 
 
1584
case 0x4a:
 
1585
M6502_IMPLIED
 
1586
M6502_LSRA
 
1587
break;
 
1588
 
 
1589
 
 
1590
case 0x46:
 
1591
M6502_ZERO_READMODIFYWRITE
 
1592
M6502_LSR
 
1593
break;
 
1594
 
 
1595
case 0x56:
 
1596
M6502_ZEROX_READMODIFYWRITE
 
1597
M6502_LSR
 
1598
break;
 
1599
 
 
1600
case 0x4e:
 
1601
M6502_ABSOLUTE_READMODIFYWRITE
 
1602
M6502_LSR
 
1603
break;
 
1604
 
 
1605
case 0x5e:
 
1606
M6502_ABSOLUTEX_READMODIFYWRITE
 
1607
M6502_LSR
 
1608
break;
 
1609
 
 
1610
 
 
1611
case 0xab:
 
1612
M6502_IMMEDIATE_READ
 
1613
M6502_LXA
 
1614
break;
 
1615
 
 
1616
 
 
1617
case 0x1a:
 
1618
case 0x3a:
 
1619
case 0x5a:
 
1620
case 0x7a:
 
1621
case 0xda:
 
1622
case 0xea:
 
1623
case 0xfa:
 
1624
M6502_IMPLIED
 
1625
M6502_NOP
 
1626
break;
 
1627
 
 
1628
case 0x80:
 
1629
case 0x82:
 
1630
case 0x89:
 
1631
case 0xc2:
 
1632
case 0xe2:
 
1633
M6502_IMMEDIATE_READ
 
1634
M6502_NOP
 
1635
break;
 
1636
 
 
1637
case 0x04:
 
1638
case 0x44:
 
1639
case 0x64:
 
1640
M6502_ZERO_READ
 
1641
M6502_NOP
 
1642
break;
 
1643
 
 
1644
case 0x14:
 
1645
case 0x34:
 
1646
case 0x54:
 
1647
case 0x74:
 
1648
case 0xd4:
 
1649
case 0xf4:
 
1650
M6502_ZEROX_READ
 
1651
M6502_NOP
 
1652
break;
 
1653
 
 
1654
case 0x0c:
 
1655
M6502_ABSOLUTE_READ
 
1656
M6502_NOP
 
1657
break;
 
1658
 
 
1659
case 0x1c:
 
1660
case 0x3c:
 
1661
case 0x5c:
 
1662
case 0x7c:
 
1663
case 0xdc:
 
1664
case 0xfc:
 
1665
M6502_ABSOLUTEX_READ
 
1666
M6502_NOP
 
1667
break;
 
1668
 
 
1669
 
 
1670
case 0x09:
 
1671
M6502_IMMEDIATE_READ
 
1672
M6502_ORA
 
1673
break;
 
1674
 
 
1675
case 0x05:
 
1676
M6502_ZERO_READ
 
1677
M6502_ORA
 
1678
break;
 
1679
 
 
1680
case 0x15:
 
1681
M6502_ZEROX_READ
 
1682
M6502_ORA
 
1683
break;
 
1684
 
 
1685
case 0x0d:
 
1686
M6502_ABSOLUTE_READ
 
1687
M6502_ORA
 
1688
break;
 
1689
 
 
1690
case 0x1d:
 
1691
M6502_ABSOLUTEX_READ
 
1692
M6502_ORA
 
1693
break;
 
1694
 
 
1695
case 0x19:
 
1696
M6502_ABSOLUTEY_READ
 
1697
M6502_ORA
 
1698
break;
 
1699
 
 
1700
case 0x01:
 
1701
M6502_INDIRECTX_READ
 
1702
M6502_ORA
 
1703
break;
 
1704
 
 
1705
case 0x11:
 
1706
M6502_INDIRECTY_READ
 
1707
M6502_ORA
 
1708
break;
 
1709
 
 
1710
 
 
1711
case 0x48:
 
1712
M6502_IMPLIED
 
1713
M6502_PHA
 
1714
break;
 
1715
 
 
1716
 
 
1717
case 0x08:
 
1718
M6502_IMPLIED
 
1719
M6502_PHP
 
1720
break;
 
1721
 
 
1722
 
 
1723
case 0x68:
 
1724
M6502_IMPLIED
 
1725
M6502_PLA
 
1726
break;
 
1727
 
 
1728
 
 
1729
case 0x28:
 
1730
M6502_IMPLIED
 
1731
M6502_PLP
 
1732
break;
 
1733
 
 
1734
 
 
1735
case 0x2f:
 
1736
M6502_ABSOLUTE_READMODIFYWRITE
 
1737
M6502_RLA
 
1738
break;
 
1739
 
 
1740
case 0x3f:
 
1741
M6502_ABSOLUTEX_READMODIFYWRITE
 
1742
M6502_RLA
 
1743
break;
 
1744
 
 
1745
case 0x3b:
 
1746
M6502_ABSOLUTEY_READMODIFYWRITE
 
1747
M6502_RLA
 
1748
break;
 
1749
 
 
1750
case 0x27:
 
1751
M6502_ZERO_READMODIFYWRITE
 
1752
M6502_RLA
 
1753
break;
 
1754
 
 
1755
case 0x37:
 
1756
M6502_ZEROX_READMODIFYWRITE
 
1757
M6502_RLA
 
1758
break;
 
1759
 
 
1760
case 0x23:
 
1761
M6502_INDIRECTX_READMODIFYWRITE
 
1762
M6502_RLA
 
1763
break;
 
1764
 
 
1765
case 0x33:
 
1766
M6502_INDIRECTY_READMODIFYWRITE
 
1767
M6502_RLA
 
1768
break;
 
1769
 
 
1770
 
 
1771
case 0x2a:
 
1772
M6502_IMPLIED
 
1773
M6502_ROLA
 
1774
break;
 
1775
 
 
1776
 
 
1777
case 0x26:
 
1778
M6502_ZERO_READMODIFYWRITE
 
1779
M6502_ROL
 
1780
break;
 
1781
 
 
1782
case 0x36:
 
1783
M6502_ZEROX_READMODIFYWRITE
 
1784
M6502_ROL
 
1785
break;
 
1786
 
 
1787
case 0x2e:
 
1788
M6502_ABSOLUTE_READMODIFYWRITE
 
1789
M6502_ROL
 
1790
break;
 
1791
 
 
1792
case 0x3e:
 
1793
M6502_ABSOLUTEX_READMODIFYWRITE
 
1794
M6502_ROL
 
1795
break;
 
1796
 
 
1797
 
 
1798
case 0x6a:
 
1799
M6502_IMPLIED
 
1800
M6502_RORA
 
1801
break;
 
1802
 
 
1803
case 0x66:
 
1804
M6502_ZERO_READMODIFYWRITE
 
1805
M6502_ROR
 
1806
break;
 
1807
 
 
1808
case 0x76:
 
1809
M6502_ZEROX_READMODIFYWRITE
 
1810
M6502_ROR
 
1811
break;
 
1812
 
 
1813
case 0x6e:
 
1814
M6502_ABSOLUTE_READMODIFYWRITE
 
1815
M6502_ROR
 
1816
break;
 
1817
 
 
1818
case 0x7e:
 
1819
M6502_ABSOLUTEX_READMODIFYWRITE
 
1820
M6502_ROR
 
1821
break;
 
1822
 
 
1823
 
 
1824
case 0x6f:
 
1825
M6502_ABSOLUTE_READMODIFYWRITE
 
1826
M6502_RRA
 
1827
break;
 
1828
 
 
1829
case 0x7f:
 
1830
M6502_ABSOLUTEX_READMODIFYWRITE
 
1831
M6502_RRA
 
1832
break;
 
1833
 
 
1834
case 0x7b:
 
1835
M6502_ABSOLUTEY_READMODIFYWRITE
 
1836
M6502_RRA
 
1837
break;
 
1838
 
 
1839
case 0x67:
 
1840
M6502_ZERO_READMODIFYWRITE
 
1841
M6502_RRA
 
1842
break;
 
1843
 
 
1844
case 0x77:
 
1845
M6502_ZEROX_READMODIFYWRITE
 
1846
M6502_RRA
 
1847
break;
 
1848
 
 
1849
case 0x63:
 
1850
M6502_INDIRECTX_READMODIFYWRITE
 
1851
M6502_RRA
 
1852
break;
 
1853
 
 
1854
case 0x73:
 
1855
M6502_INDIRECTY_READMODIFYWRITE
 
1856
M6502_RRA
 
1857
break;
 
1858
 
 
1859
 
 
1860
case 0x40:
 
1861
M6502_IMPLIED
 
1862
M6502_RTI
 
1863
break;
 
1864
 
 
1865
 
 
1866
case 0x60:
 
1867
M6502_IMPLIED
 
1868
M6502_RTS
 
1869
break;
 
1870
 
 
1871
 
 
1872
case 0x8f:
 
1873
M6502_ABSOLUTE_WRITE
 
1874
M6502_SAX
 
1875
break;
 
1876
 
 
1877
case 0x87:
 
1878
M6502_ZERO_WRITE
 
1879
M6502_SAX
 
1880
break;
 
1881
 
 
1882
case 0x97:
 
1883
M6502_ZEROY_WRITE
 
1884
M6502_SAX
 
1885
break;
 
1886
 
 
1887
case 0x83:
 
1888
M6502_INDIRECTX_WRITE
 
1889
M6502_SAX
 
1890
break;
 
1891
 
 
1892
 
 
1893
case 0xe9:
 
1894
case 0xeb:
 
1895
M6502_IMMEDIATE_READ
 
1896
M6502_SBC
 
1897
break;
 
1898
 
 
1899
case 0xe5:
 
1900
M6502_ZERO_READ
 
1901
M6502_SBC
 
1902
break;
 
1903
 
 
1904
case 0xf5:
 
1905
M6502_ZEROX_READ
 
1906
M6502_SBC
 
1907
break;
 
1908
 
 
1909
case 0xed:
 
1910
M6502_ABSOLUTE_READ
 
1911
M6502_SBC
 
1912
break;
 
1913
 
 
1914
case 0xfd:
 
1915
M6502_ABSOLUTEX_READ
 
1916
M6502_SBC
 
1917
break;
 
1918
 
 
1919
case 0xf9:
 
1920
M6502_ABSOLUTEY_READ
 
1921
M6502_SBC
 
1922
break;
 
1923
 
 
1924
case 0xe1:
 
1925
M6502_INDIRECTX_READ
 
1926
M6502_SBC
 
1927
break;
 
1928
 
 
1929
case 0xf1:
 
1930
M6502_INDIRECTY_READ
 
1931
M6502_SBC
 
1932
break;
 
1933
 
 
1934
 
 
1935
case 0xcb:
 
1936
M6502_IMMEDIATE_READ
 
1937
M6502_SBX
 
1938
break;
 
1939
 
 
1940
 
 
1941
case 0x38:
 
1942
M6502_IMPLIED
 
1943
M6502_SEC
 
1944
break;
 
1945
 
 
1946
 
 
1947
case 0xf8:
 
1948
M6502_IMPLIED
 
1949
M6502_SED
 
1950
break;
 
1951
 
 
1952
 
 
1953
case 0x78:
 
1954
M6502_IMPLIED
 
1955
M6502_SEI
 
1956
break;
 
1957
 
 
1958
 
 
1959
case 0x9f:
 
1960
M6502_ABSOLUTEY_WRITE
 
1961
M6502_SHA
 
1962
break;
 
1963
 
 
1964
case 0x93:
 
1965
M6502_INDIRECTY_WRITE
 
1966
M6502_SHA
 
1967
break;
 
1968
 
 
1969
 
 
1970
case 0x9b:
 
1971
M6502_ABSOLUTEY_WRITE
 
1972
M6502_SHS
 
1973
break;
 
1974
 
 
1975
 
 
1976
case 0x9e:
 
1977
M6502_ABSOLUTEY_WRITE
 
1978
M6502_SHX
 
1979
break;
 
1980
 
 
1981
 
 
1982
case 0x9c:
 
1983
M6502_ABSOLUTEX_WRITE
 
1984
M6502_SHY
 
1985
break;
 
1986
 
 
1987
 
 
1988
case 0x0f:
 
1989
M6502_ABSOLUTE_READMODIFYWRITE
 
1990
M6502_SLO
 
1991
break;
 
1992
 
 
1993
case 0x1f:
 
1994
M6502_ABSOLUTEX_READMODIFYWRITE
 
1995
M6502_SLO
 
1996
break;
 
1997
 
 
1998
case 0x1b:
 
1999
M6502_ABSOLUTEY_READMODIFYWRITE
 
2000
M6502_SLO
 
2001
break;
 
2002
 
 
2003
case 0x07:
 
2004
M6502_ZERO_READMODIFYWRITE
 
2005
M6502_SLO
 
2006
break;
 
2007
 
 
2008
case 0x17:
 
2009
M6502_ZEROX_READMODIFYWRITE
 
2010
M6502_SLO
 
2011
break;
 
2012
 
 
2013
case 0x03:
 
2014
M6502_INDIRECTX_READMODIFYWRITE
 
2015
M6502_SLO
 
2016
break;
 
2017
 
 
2018
case 0x13:
 
2019
M6502_INDIRECTY_READMODIFYWRITE
 
2020
M6502_SLO
 
2021
break;
 
2022
 
 
2023
 
 
2024
case 0x4f:
 
2025
M6502_ABSOLUTE_READMODIFYWRITE
 
2026
M6502_SRE
 
2027
break;
 
2028
 
 
2029
case 0x5f:
 
2030
M6502_ABSOLUTEX_READMODIFYWRITE
 
2031
M6502_SRE
 
2032
break;
 
2033
 
 
2034
case 0x5b:
 
2035
M6502_ABSOLUTEY_READMODIFYWRITE
 
2036
M6502_SRE
 
2037
break;
 
2038
 
 
2039
case 0x47:
 
2040
M6502_ZERO_READMODIFYWRITE
 
2041
M6502_SRE
 
2042
break;
 
2043
 
 
2044
case 0x57:
 
2045
M6502_ZEROX_READMODIFYWRITE
 
2046
M6502_SRE
 
2047
break;
 
2048
 
 
2049
case 0x43:
 
2050
M6502_INDIRECTX_READMODIFYWRITE
 
2051
M6502_SRE
 
2052
break;
 
2053
 
 
2054
case 0x53:
 
2055
M6502_INDIRECTY_READMODIFYWRITE
 
2056
M6502_SRE
 
2057
break;
 
2058
 
 
2059
 
 
2060
case 0x85:
 
2061
M6502_ZERO_WRITE
 
2062
M6502_STA
 
2063
break;
 
2064
 
 
2065
case 0x95:
 
2066
M6502_ZEROX_WRITE
 
2067
M6502_STA
 
2068
break;
 
2069
 
 
2070
case 0x8d:
 
2071
M6502_ABSOLUTE_WRITE
 
2072
M6502_STA
 
2073
break;
 
2074
 
 
2075
case 0x9d:
 
2076
M6502_ABSOLUTEX_WRITE
 
2077
M6502_STA
 
2078
break;
 
2079
 
 
2080
case 0x99:
 
2081
M6502_ABSOLUTEY_WRITE
 
2082
M6502_STA
 
2083
break;
 
2084
 
 
2085
case 0x81:
 
2086
M6502_INDIRECTX_WRITE
 
2087
M6502_STA
 
2088
break;
 
2089
 
 
2090
case 0x91:
 
2091
M6502_INDIRECTY_WRITE
 
2092
M6502_STA
 
2093
break;
 
2094
 
 
2095
 
 
2096
case 0x86:
 
2097
M6502_ZERO_WRITE
 
2098
M6502_STX
 
2099
break;
 
2100
 
 
2101
case 0x96:
 
2102
M6502_ZEROY_WRITE
 
2103
M6502_STX
 
2104
break;
 
2105
 
 
2106
case 0x8e:
 
2107
M6502_ABSOLUTE_WRITE
 
2108
M6502_STX
 
2109
break;
 
2110
 
 
2111
 
 
2112
case 0x84:
 
2113
M6502_ZERO_WRITE
 
2114
M6502_STY
 
2115
break;
 
2116
 
 
2117
case 0x94:
 
2118
M6502_ZEROX_WRITE
 
2119
M6502_STY
 
2120
break;
 
2121
 
 
2122
case 0x8c:
 
2123
M6502_ABSOLUTE_WRITE
 
2124
M6502_STY
 
2125
break;
 
2126
 
 
2127
 
 
2128
case 0xaa:
 
2129
M6502_IMPLIED
 
2130
M6502_TAX
 
2131
break;
 
2132
 
 
2133
 
 
2134
case 0xa8:
 
2135
M6502_IMPLIED
 
2136
M6502_TAY
 
2137
break;
 
2138
 
 
2139
 
 
2140
case 0xba:
 
2141
M6502_IMPLIED
 
2142
M6502_TSX
 
2143
break;
 
2144
 
 
2145
 
 
2146
case 0x8a:
 
2147
M6502_IMPLIED
 
2148
M6502_TXA
 
2149
break;
 
2150
 
 
2151
 
 
2152
case 0x9a:
 
2153
M6502_IMPLIED
 
2154
M6502_TXS
 
2155
break;
 
2156
 
 
2157
 
 
2158
case 0x98:
 
2159
M6502_IMPLIED
 
2160
M6502_TYA
 
2161
break;
 
2162
 
 
2163