CoCalc -- gen68k.c

GitHub Repository: alexbevi/BizHawk
Path: blob/master/yabause/src/c68k/gen68k.c
² views
1
/*  Copyright 2003-2004 Stephane Dallongeville
2

3
    This file is part of Yabause.
4

5
    Yabause is free software; you can redistribute it and/or modify
6
    it under the terms of the GNU General Public License as published by
7
    the Free Software Foundation; either version 2 of the License, or
8
    (at your option) any later version.
9

10
    Yabause is distributed in the hope that it will be useful,
11
    but WITHOUT ANY WARRANTY; without even the implied warranty of
12
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
    GNU General Public License for more details.
14

15
    You should have received a copy of the GNU General Public License
16
    along with Yabause; if not, write to the Free Software
17
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
18
*/
19

20
/*********************************************************************************
21
 * GEN68K.C :
22
 *
23
 * C68K generator source file
24
 *
25
 ********************************************************************************/
26

27
#include <stdio.h>
28
#ifdef __WIN32__
29
#include <windows.h>
30
#endif
31

32
#include "../core.h"
33
#include "c68k.h"
34
#include "gen68k.h"
35

36
#ifdef C68K_GEN
37

38
#include "gen68k.inc"
39

40
// to do :
41
// need accurate cycles calculations in MUL and DIV instruction
42
// some bugs to fix
43

44
// opcode generation function
45
//////////////////////////////
46

47
static void GenLogicI(char op)
48
{
49
    // generate jump table & opcode declaration
50
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
51
        start_all(GEN_RES | GEN_SRC);
52
    else
53
        start_all(GEN_ADR | GEN_RES | GEN_SRC);
54

55
    if (current_ea != EA_DREG) current_cycle += 4;
56
    switch (current_size)
57
    {
58
        case SIZE_BYTE:
59
            wf_op("\tsrc = FETCH_BYTE;\n");
60
            wf_op("\tPC += 2;\n");
61
            break;
62

63
        case SIZE_WORD:
64
            wf_op("\tsrc = FETCH_WORD;\n");
65
            wf_op("\tPC += 2;\n");
66
            break;
67

68
        case SIZE_LONG:
69
            wf_op("\tsrc = FETCH_LONG;\n");
70
            wf_op("\tPC += 4;\n");
71
            current_cycle += 8;
72
            break;
73
    }
74

75
    // read
76
    _ea_calc(current_ea, current_op->reg_sft);
77
    _ea_read(current_ea, current_op->reg_sft);
78
    // op
79
    wf_op("\tres %c= src;\n", op);
80
    // flag calculation
81
    set_logic_flag();
82
    // write
83
    _ea_write(current_ea, current_op->reg_sft);
84

85
    terminate_op(8);
86
}
87

88
static void GenLogicICCR(char op)
89
{
90
    // generate jump table & opcode declaration
91
    start_all(GEN_RES);
92

93
    wf_op("\tres = FETCH_BYTE & C68K_CCR_MASK;\n");
94
    wf_op("\tPC += 2;\n");
95
    wf_op("\tres %c= GET_CCR;\n", op);
96
    wf_op("\tSET_CCR(res)\n");
97

98
    terminate_op(20);
99
}
100

101
static void GenLogicISR(char op)
102
{
103
    // generate jump table & opcode declaration
104
    start_all(GEN_RES);
105
    
106
    wf_op("\tif (CPU->flag_S)\n");
107
    wf_op("\t{\n");
108
    wf_op("\t\tres = FETCH_WORD & C68K_SR_MASK;\n");
109
    wf_op("\t\tPC += 2;\n");
110
    wf_op("\t\tres %c= GET_SR;\n", op);
111
    wf_op("\t\tSET_SR(res)\n");
112
    if (op != '|')
113
    {
114
        wf_op("\t\tif (!CPU->flag_S)\n");
115
        wf_op("\t\t{\n");
116
        wf_op("\t\t\tres = CPU->A[7];\n");
117
        wf_op("\t\t\tCPU->A[7] = CPU->USP;\n");
118
        wf_op("\t\t\tCPU->USP = res;\n");
119
        wf_op("\t\t}\n");
120
    }
121
    wf_op("\t}\n");
122
    wf_op("\telse\n");
123
    wf_op("\t{\n");
124
        gen_privilege_exception("\t\t");
125
    wf_op("\t}\n");
126

127
    // check for interrupt
128
    fterminate_op(20);
129
}
130

131
static void GenORI()
132
{
133
    GenLogicI('|');
134
}
135

136
static void GenORICCR()
137
{
138
    GenLogicICCR('|');
139
}
140

141
static void GenORISR()
142
{
143
    GenLogicISR('|');
144
}
145

146
static void GenANDI()
147
{
148
    GenLogicI('&');
149
}
150

151
static void GenANDICCR()
152
{
153
    GenLogicICCR('&');
154
}
155

156
static void GenANDISR()
157
{
158
    GenLogicISR('&');
159
}
160

161
static void GenEORI()
162
{
163
    GenLogicI('^');
164
}
165

166
static void GenEORICCR()
167
{
168
    GenLogicICCR('^');
169
}
170

171
static void GenEORISR()
172
{
173
    GenLogicISR('^');
174
}
175

176
static void GenArithI(char op)
177
{
178
    // generate jump table & opcode declaration
179
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
180
        start_all(GEN_RES | GEN_SRC | GEN_DST);
181
    else
182
        start_all(GEN_ALL);
183

184
    if ((op != ' ') && (current_ea != EA_DREG)) current_cycle += 4;
185
    switch (current_size)
186
    {
187
        case SIZE_BYTE:
188
            wf_op("\tsrc = FETCH_BYTE;\n");
189
            wf_op("\tPC += 2;\n");
190
            break;
191

192
        case SIZE_WORD:
193
            wf_op("\tsrc = FETCH_WORD;\n");
194
            wf_op("\tPC += 2;\n");
195
            break;
196

197
        case SIZE_LONG:
198
            wf_op("\tsrc = FETCH_LONG;\n");
199
            wf_op("\tPC += 4;\n");
200
            if (op == ' ')
201
            {
202
                if (current_ea == EA_DREG) current_cycle += 6;
203
                else current_cycle += 4;
204
            } else current_cycle += 8;
205
            break;
206
    }
207

208
    // read
209
    _ea_calc(current_ea, current_op->reg_sft);
210
    _ea_read_dst(current_ea, current_op->reg_sft);
211
    if (op == ' ')
212
    {
213
        // op
214
        wf_op("\tres = dst - src;\n");
215
        // flag calculation
216
        set_cmp_flag();
217
    }
218
    else
219
    {
220
        // op
221
        wf_op("\tres = dst %c src;\n", op);
222
        // flag calculation
223
        if (op == '+') set_add_flag();
224
        else set_sub_flag();
225
        // write
226
        _ea_write(current_ea, current_op->reg_sft);
227
    }
228

229
    terminate_op(8);
230
}
231

232
static void GenSUBI()
233
{
234
    GenArithI('-');
235
}
236

237
static void GenADDI()
238
{
239
    GenArithI('+');
240
}
241

242
static void GenCMPI()
243
{
244
    GenArithI(' ');
245
}
246

247
static void GenBitsOp(char op, u32 dyn)
248
{
249
    // generate jump table & opcode declaration
250
    if (dyn) current_ea2 = EA_DREG;
251
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
252
        start_all(GEN_RES | GEN_SRC);
253
    else
254
        start_all(GEN_ADR | GEN_RES | GEN_SRC);
255
    
256
    if (current_ea == EA_DREG)
257
    {
258
        set_current_size(SIZE_LONG);
259
        if ((op == 'c') || (op == ' ')) current_cycle += 2;
260
    }
261
    else set_current_size(SIZE_BYTE);
262
    
263
    // get shift value in src
264
    if (dyn)
265
    {
266
        _ea_calc(current_ea2, current_op->reg2_sft);
267
        _ea_read_src(current_ea2, current_op->reg2_sft);
268
    }
269
    else
270
    {
271
        wf_op("\tsrc = FETCH_BYTE;\n");
272
        wf_op("\tPC += 2;\n");
273
        current_cycle += 4;
274
    }
275
    wf_op("\tsrc = 1 << (src & %d);\n", current_sft_mask);
276
    
277
    // read
278
    _ea_calc(current_ea, current_op->reg_sft);
279
    _ea_read(current_ea, current_op->reg_sft);
280
    // flag calculation
281
    wf_op("\tCPU->flag_notZ = res & src;\n");
282
    // op
283
    switch(op)
284
    {
285
        case 'c':
286
            wf_op("\tres &= ~src;\n");
287
            break;
288

289
        case 'g':
290
            wf_op("\tres ^= src;\n");
291
            break;
292

293
        case 's':
294
            wf_op("\tres |= src;\n");
295
            break;
296
    }
297
    // write
298
    if (op != ' ')
299
    {
300
        _ea_write(current_ea, current_op->reg_sft);
301
        current_cycle += 4;
302
    }
303

304
    terminate_op(4);
305
}
306

307
static void GenBTSTn()
308
{
309
    GenBitsOp(' ', 0);
310
}
311

312
static void GenBCHGn()
313
{
314
    GenBitsOp('g', 0);
315
}
316

317
static void GenBCLRn()
318
{
319
    GenBitsOp('c', 0);
320
}
321

322
static void GenBSETn()
323
{
324
    GenBitsOp('s', 0);
325
}
326

327
static void GenBTST()
328
{
329
    GenBitsOp(' ', 1);
330
}
331

332
static void GenBCHG()
333
{
334
    GenBitsOp('g', 1);
335
}
336

337
static void GenBCLR()
338
{
339
    GenBitsOp('c', 1);
340
}
341

342
static void GenBSET()
343
{
344
    GenBitsOp('s', 1);
345
}
346

347
static void GenMOVEPWaD()
348
{
349
    // generate jump table & opcode declaration
350
    current_ea = EA_D16A;
351
    current_ea2 = EA_DREG;
352
    start_all(GEN_ADR | GEN_RES | GEN_SRC);
353

354
    // read
355
    set_current_size(SIZE_BYTE);
356
    _ea_calc(current_ea, current_op->reg_sft);
357
    mem_op("\tREAD_BYTE_F(adr + 0, res)\n");
358
    mem_op("\tREAD_BYTE_F(adr + 2, src)\n");
359
    // write
360
    wf_op("\t*(u16*)(&CPU->D[(Opcode >> %d) & 7]) = (res << 8) | src;\n", current_op->reg2_sft);
361

362
    terminate_op(16);
363
}
364

365
static void GenMOVEPLaD()
366
{
367
    // generate jump table & opcode declaration
368
    current_ea = EA_D16A;
369
    current_ea2 = EA_DREG;
370
    start_all(GEN_ADR | GEN_RES | GEN_SRC);
371

372
    // read
373
    set_current_size(SIZE_BYTE);
374
    _ea_calc(EA_D16A, current_op->reg_sft);
375
    mem_op("\tREAD_BYTE_F(adr, res)\n");
376
    wf_op("\tres <<= 24;\n");
377
    wf_op("\tadr += 2;\n");
378
    mem_op("\tREAD_BYTE_F(adr, src)\n");
379
    wf_op("\tres |= src << 16;\n");
380
    wf_op("\tadr += 2;\n");
381
    mem_op("\tREAD_BYTE_F(adr, src)\n");
382
    wf_op("\tres |= src << 8;\n");
383
    wf_op("\tadr += 2;\n");
384
    mem_op("\tREAD_BYTE_F(adr, src)\n");
385
    // write
386
    wf_op("\tCPU->D[(Opcode >> %d) & 7] = res | src;\n", current_op->reg2_sft);
387

388
    terminate_op(24);
389
}
390

391
static void GenMOVEPWDa()
392
{
393
    // generate jump table & opcode declaration
394
    current_ea = EA_D16A;
395
    current_ea2 = EA_DREG;
396
    start_all(GEN_ADR | GEN_RES);
397

398
    // read
399
    set_current_size(SIZE_LONG);
400
    _ea_calc(current_ea2, current_op->reg2_sft);
401
    _ea_read(current_ea2, current_op->reg2_sft);
402
    // write
403
    set_current_size(SIZE_BYTE);
404
    _ea_calc(current_ea, current_op->reg_sft);
405
    mem_op("\tWRITE_BYTE_F(adr + 0, res >> 8)\n");
406
    mem_op("\tWRITE_BYTE_F(adr + 2, res >> 0)\n");
407

408
    terminate_op(16);
409
}
410

411
static void GenMOVEPLDa()
412
{
413
    // generate jump table & opcode declaration
414
    current_ea = EA_D16A;
415
    current_ea2 = EA_DREG;
416
    start_all(GEN_ADR | GEN_RES);
417

418
    // read
419
    set_current_size(SIZE_LONG);
420
    _ea_calc(current_ea2, current_op->reg2_sft);
421
    _ea_read(current_ea2, current_op->reg2_sft);
422
    // write
423
    set_current_size(SIZE_BYTE);
424
    _ea_calc(current_ea, current_op->reg_sft);
425
    mem_op("\tWRITE_BYTE_F(adr, res >> 24)\n");
426
    wf_op("\tadr += 2;\n");
427
    mem_op("\tWRITE_BYTE_F(adr, res >> 16)\n");
428
    wf_op("\tadr += 2;\n");
429
    mem_op("\tWRITE_BYTE_F(adr, res >> 8)\n");
430
    wf_op("\tadr += 2;\n");
431
    mem_op("\tWRITE_BYTE_F(adr, res >> 0)\n");
432

433
    terminate_op(24);
434
}
435

436
static void GenMOVE(u32 size)
437
{
438
    set_current_size(size);
439
    
440
    // generate jump table & opcode declaration
441
    if (((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) &&
442
        ((current_ea2 == EA_AREG) || (current_ea2 == EA_DREG) || (current_ea2 == EA_IMM)))
443
        start_all(GEN_RES);
444
    else
445
        start_all(GEN_ADR | GEN_RES);
446
    
447
    // read
448
    _ea_calc(current_ea, current_op->reg_sft);
449
    _ea_read(current_ea, current_op->reg_sft);
450
    // flag calculation
451
    set_logic_flag();
452
    if ((current_ea2 == EA_ADEC) || (current_ea2 == EA_ADEC7)) current_cycle -= 2;
453
    // write
454
    _ea_calc(current_ea2, current_op->reg2_sft);
455
    _ea_write(current_ea2, current_op->reg2_sft);
456

457
    terminate_op(4);
458
}
459

460
static void GenMOVEB()
461
{
462
    GenMOVE(SIZE_BYTE);
463
}
464

465
static void GenMOVEW()
466
{
467
    GenMOVE(SIZE_WORD);
468
}
469

470
static void GenMOVEL()
471
{
472
    GenMOVE(SIZE_LONG);
473
}
474

475
static void GenMOVEA(u32 size)
476
{
477
    set_current_size(size);
478

479
    // generate jump table & opcode declaration
480
    current_ea2 = EA_AREG;
481
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
482
        start_all(GEN_RES);
483
    else
484
        start_all(GEN_ADR | GEN_RES);
485

486
    // read
487
    _ea_calc(current_ea, current_op->reg_sft);
488
    _ea_read_sx(current_ea, current_op->reg_sft);
489
    // write (dst = Ax)
490
    _ea_calc(current_ea2, current_op->reg2_sft);
491
    _ea_write(current_ea2, current_op->reg2_sft);
492

493
    terminate_op(4);
494
}
495

496
static void GenMOVEAW()
497
{
498
    GenMOVEA(SIZE_WORD);
499
}
500

501
static void GenMOVEAL()
502
{
503
    GenMOVEA(SIZE_LONG);
504
}
505

506
static void GenMOVEQ()
507
{
508
    u32 base = get_current_opcode_base();
509

510
    // generate jump table
511
    current_ea = EA_DREG;
512
    gen_opjumptable_ext(base, 0x00, 0xFF, 1, base);
513

514
    // generate label & declarations
515
    start_op(base, GEN_RES);
516

517
    // read
518
    set_current_size(SIZE_BYTE);
519
	wf_op("\tres = (s32)(s8)Opcode;\n");
520
    // fast flag calculation for moveQ
521
	wf_op("\tCPU->flag_C = CPU->flag_V = 0;\n");
522
	wf_op("\tCPU->flag_N = CPU->flag_notZ = res;\n");
523
    // write
524
    set_current_size(SIZE_LONG);
525
    _ea_calc(current_ea, current_op->reg_sft);
526
    _ea_write(current_ea, current_op->reg_sft);
527

528
    terminate_op(4);
529
}
530

531
static void GenSingle(char op)
532
{
533
    // generate jump table & opcode declaration
534
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) {
535
        if (op == 'c')
536
            start_all(GEN_RES);
537
        else
538
            start_all(GEN_RES | GEN_SRC);
539
    } else {
540
        if (op == 'c')
541
            start_all(GEN_ADR | GEN_RES);
542
        else
543
            start_all(GEN_ADR | GEN_RES | GEN_SRC);
544
    }
545

546
    if (current_size == SIZE_LONG) current_cycle = 6;
547
    else current_cycle= 4;
548
    if (is_ea_memory(current_ea)) current_cycle *= 2;
549
    
550
    // read
551
    _ea_calc(current_ea, current_op->reg_sft);
552
    if (op != 'c') _ea_read_src(current_ea, current_op->reg_sft);
553
    // op
554
    switch (op)
555
    {
556
        case 'x':   // negx
557
            wf_op("\tres = -src - ((CPU->flag_X >> 8) & 1);\n");
558
            break;
559
            
560
        case 'g':   // neg
561
            wf_op("\tres = -src;\n");
562
            break;
563

564
        case 'n':   // not
565
            wf_op("\tres = ~src;\n");
566
            break;
567

568
        case 'c':   // clr
569
            wf_op("\tres = 0;\n");
570
            break;
571
    }
572
    // flag calculation
573
    switch (op)
574
    {
575
        case 'x':   // negx
576
            set_negx_flag();
577
            break;
578

579
        case 'g':   // neg
580
            set_neg_flag();
581
            break;
582

583
        case 'n':   // not
584
            set_logicl_flag();
585
            break;
586

587
        case 'c':   // clr
588
            wf_op("\tCPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0;\n");
589
            break;
590
    }
591
    // write
592
    _ea_write(current_ea, current_op->reg_sft);
593

594
    terminate_op(0);
595
}
596

597
static void GenCLR()
598
{
599
    GenSingle('c');
600
}
601

602
static void GenNEGX()
603
{
604
    GenSingle('x');
605
}
606

607
static void GenNEG()
608
{
609
    GenSingle('g');
610
}
611

612
static void GenNOT()
613
{
614
    GenSingle('n');
615
}
616

617
static void GenMOVESRa()
618
{
619
    // generate jump table & opcode declaration
620
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
621
        start_all(GEN_RES);
622
    else
623
        start_all(GEN_ADR | GEN_RES);
624

625
    // read
626
    wf_op("\tres = GET_SR;\n");
627
    // write
628
    set_current_size(SIZE_WORD);
629
    if (is_ea_memory(current_ea)) current_cycle += 2;
630
    _ea_calc(current_ea, current_op->reg_sft);
631
    _ea_write(current_ea, current_op->reg_sft);
632

633
    terminate_op(6);
634
}
635

636
static void GenMOVEaSR()
637
{
638
    // generate jump table & opcode declaration
639
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
640
        start_all(GEN_RES);
641
    else
642
        start_all(GEN_ADR | GEN_RES);
643

644
    wf_op("\tif (CPU->flag_S)\n");
645
    wf_op("\t{\n");
646
        // read
647
        set_current_size(SIZE_WORD);
648
        _ea_calc(current_ea, current_op->reg_sft);
649
        _ea_read(current_ea, current_op->reg_sft);
650
        wf_op("\t\tSET_SR(res)\n");
651
        wf_op("\t\tif (!CPU->flag_S)\n");
652
        wf_op("\t\t{\n");
653
            wf_op("\t\t\tres = CPU->A[7];\n");
654
            wf_op("\t\t\tCPU->A[7] = CPU->USP;\n");
655
            wf_op("\t\t\tCPU->USP = res;\n");
656
        wf_op("\t\t}\n");
657
    wf_op("\t}\n");
658
    wf_op("\telse\n");
659
    wf_op("\t{\n");
660
        gen_privilege_exception("\t\t");
661
    wf_op("\t}\n");
662

663
    // force terminaison to check for interrupt
664
    fterminate_op(12);
665
}
666

667
static void GenMOVEaCCR()
668
{
669
    // generate jump table & opcode declaration
670
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
671
        start_all(GEN_RES);
672
    else
673
        start_all(GEN_ADR | GEN_RES);
674

675
    // read
676
    set_current_size(SIZE_WORD);
677
    _ea_calc(current_ea, current_op->reg_sft);
678
    _ea_read(current_ea, current_op->reg_sft);
679
    // write
680
    wf_op("\tSET_CCR(res)\n");
681

682
    terminate_op(12);
683
}
684

685
static void GenMOVEAUSP()
686
{
687
    current_ea = EA_AREG;
688

689
    // generate jump table & opcode declaration
690
    start_all(GEN_RES);
691

692
    wf_op("\tif (!CPU->flag_S)\n");
693
    wf_op("\t{\n");
694
        gen_privilege_exception("\t\t");
695
        quick_terminate_op(4);
696
    wf_op("\t}\n");
697

698
    // read
699
    set_current_size(SIZE_LONG);
700
    _ea_calc(current_ea, current_op->reg_sft);
701
    _ea_read(current_ea, current_op->reg_sft);
702
    // write
703
     wf_op("\tCPU->USP = res;\n");
704

705
    terminate_op(4);
706
}
707

708
static void GenMOVEUSPA()
709
{
710
    current_ea = EA_AREG;
711
    
712
    // generate jump table & opcode declaration
713
    start_all(GEN_RES);
714

715
    wf_op("\tif (!CPU->flag_S)\n");
716
    wf_op("\t{\n");
717
        gen_privilege_exception("\t\t");
718
        quick_terminate_op(4);
719
    wf_op("\t}\n");
720

721
    // read
722
     wf_op("\tres = CPU->USP;\n");
723
    // write
724
    set_current_size(SIZE_LONG);
725
    _ea_calc(current_ea, current_op->reg_sft);
726
    _ea_write(current_ea, current_op->reg_sft);
727

728
    terminate_op(4);
729
}
730

731
static void GenPEA()
732
{
733
    set_current_size(SIZE_LONG);
734
    // generate jump table & opcode declaration
735
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
736
        start_all(0);
737
    else
738
        start_all(GEN_ADR);
739
    
740
    _ea_calc_free(current_ea, current_op->reg_sft);
741
    mem_op("\tPUSH_32_F(adr)\n");
742
    
743
    terminate_op(lea_pea_cycle_table[current_ea] + 12);
744
}
745

746
static void GenSWAP()
747
{
748
    current_ea = EA_DREG;
749
    set_current_size(SIZE_LONG);
750
    // generate jump table & opcode declaration
751
    start_all(GEN_RES);
752

753
    // read
754
    _ea_calc(current_ea, current_op->reg_sft);
755
    _ea_read(current_ea, current_op->reg_sft);
756
    // op
757
    wf_op("\tres = (res >> 16) | (res << 16);\n");
758
    // flag calculation
759
    set_logic_flag();
760
    // write
761
    _ea_write(current_ea, current_op->reg_sft);
762

763
    terminate_op(4);
764
}
765

766
static void GenMOVEMaR()
767
{
768
    // generate jump table & opcode declaration
769
    start_all(GEN_ALL);
770
    
771
    // get register mask
772
    wf_op("\tres = FETCH_WORD;\n");
773
    wf_op("\tPC += 2;\n");
774
    // get adr
775
    if (current_ea == EA_AINC) wf_op("\tadr = CPU->A[(Opcode >> %d) & 7];\n", current_op->reg_sft);
776
    else if (current_ea == EA_AINC7) wf_op("\tadr = CPU->A[7];\n");
777
    else _ea_calc(current_ea, current_op->reg_sft);
778
    wf_op("\tsrc = (pointer)(&CPU->D[0]);\n");
779

780
    wf_op("\tdst = adr;\n");
781
    do_pre_io();
782
    
783
    wf_op("\tdo\n");
784
    wf_op("\t{\n");
785
    wf_op("\t\tif (res & 1)\n");
786
    wf_op("\t\t{\n");
787

788
    if (current_size == SIZE_WORD)
789
    {
790
        wf_op("\t\t\tREADSX_WORD_F(adr, *(s32*)src)\n");
791
        wf_op("\t\t\tadr += 2;\n");
792
    }
793
    else
794
    {
795
        wf_op("\t\t\tREAD_LONG_F(adr, *(u32*)src)\n");
796
        wf_op("\t\t\tadr += 4;\n");
797
    }
798
    wf_op("\t\t}\n");
799
    wf_op("\t\tsrc += 4;\n");
800
    wf_op("\t} while (res >>= 1);\n");
801

802
    if (current_ea == EA_AINC) wf_op("\tCPU->A[(Opcode >> %d) & 7] = adr;\n", current_op->reg_sft);
803
    else if (current_ea == EA_AINC7) wf_op("\tCPU->A[7] = adr;\n");
804
    adds_CCnt("(adr - dst) * 2");
805

806
    terminate_op(movem_cycle_table[current_ea] + 12);
807
}
808

809
static void GenMOVEMRa()
810
{
811
    // generate jump table & opcode declaration
812
    start_all(GEN_ALL);
813

814
    // get register mask
815
    wf_op("\tres = FETCH_WORD;\n");
816
    wf_op("\tPC += 2;\n");
817
    // get adr
818
    if (current_ea == EA_ADEC) wf_op("\tadr = CPU->A[(Opcode >> %d) & 7];\n", current_op->reg_sft);
819
    else if (current_ea == EA_ADEC7) wf_op("\tadr = CPU->A[7];\n");
820
    else _ea_calc(current_ea, current_op->reg_sft);
821
    if ((current_ea == EA_ADEC) || (current_ea == EA_ADEC7)) wf_op("\tsrc = (pointer)(&CPU->A[7]);\n");
822
    else wf_op("\tsrc = (pointer)(&CPU->D[0]);\n");
823

824
    wf_op("\tdst = adr;\n");
825
    do_pre_io();
826
    
827
    wf_op("\tdo\n");
828
    wf_op("\t{\n");
829
    wf_op("\t\tif (res & 1)\n");
830
    wf_op("\t\t{\n");
831

832
    if (current_size == SIZE_WORD)
833
    {
834
        if ((current_ea == EA_ADEC) || (current_ea == EA_ADEC7)) wf_op("\t\t\tadr -= 2;\n");
835
        wf_op("\t\t\tWRITE_WORD_F(adr, *(u16*)src)\n");
836
        if (!((current_ea == EA_ADEC) || (current_ea == EA_ADEC7))) wf_op("\t\t\tadr += 2;\n");
837
    }
838
    else
839
    {
840
        if ((current_ea == EA_ADEC) || (current_ea == EA_ADEC7))
841
        {
842
            wf_op("\t\t\tadr -= 4;\n");
843
            wf_op("\t\t\tWRITE_LONG_DEC_F(adr, *(u32*)src)\n");
844
        }
845
        else
846
        {
847
            wf_op("\t\t\tWRITE_LONG_F(adr, *(u32*)src)\n");
848
            wf_op("\t\t\tadr += 4;\n");
849
        }
850
    }
851
    wf_op("\t\t}\n");
852
    if ((current_ea == EA_ADEC) || (current_ea == EA_ADEC7)) wf_op("\t\tsrc -= 4;\n");
853
    else wf_op("\t\tsrc += 4;\n");
854
    wf_op("\t} while (res >>= 1);\n");
855

856
    if (current_ea == EA_ADEC) wf_op("\tCPU->A[(Opcode >> %d) & 7] = adr;\n", current_op->reg_sft);
857
    else if (current_ea == EA_ADEC7) wf_op("\tCPU->A[7] = adr;\n");
858
    if ((current_ea == EA_ADEC) || (current_ea == EA_ADEC7)) adds_CCnt("(dst - adr) * 2");
859
    else adds_CCnt("(adr - dst) * 2");
860

861
    terminate_op(movem_cycle_table[current_ea] + 8);
862
}
863

864
static void GenEXT()
865
{
866
    current_ea = EA_DREG;
867
    // generate jump table & opcode declaration
868
    start_all(GEN_RES);
869

870
    // read
871
    set_current_size(current_size - 1);
872
    _ea_calc(current_ea, current_op->reg_sft);
873
    _ea_read_sx(current_ea, current_op->reg_sft);
874
    // flag calculation
875
    set_logic_flag();
876
    // write
877
    set_current_size(current_size + 1);
878
    _ea_write(current_ea, current_op->reg_sft);
879
    
880
    terminate_op(4);
881
}
882

883
static void GenTST()
884
{
885
    // generate jump table & opcode declaration
886
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
887
        start_all(GEN_RES);
888
    else
889
        start_all(GEN_ADR | GEN_RES);
890

891
    // read
892
    _ea_calc(current_ea, current_op->reg_sft);
893
    _ea_read(current_ea, current_op->reg_sft);
894
    // flag calculation
895
    set_logic_flag();
896

897
    terminate_op(4);
898
}
899

900
static void GenTAS()
901
{
902
    set_current_size(SIZE_BYTE);
903
    
904
    if (is_ea_memory(current_ea)) current_cycle += 6;
905

906
    // generate jump table & opcode declaration
907
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
908
        start_all(GEN_RES);
909
    else
910
        start_all(GEN_ADR | GEN_RES);
911

912
    // read
913
    _ea_calc(current_ea, current_op->reg_sft);
914
    _ea_read(current_ea, current_op->reg_sft);
915
    // flag calculation
916
    set_logic_flag();
917
#ifndef C68K_TAS_CAN_SET_MEMORY
918
    if (current_ea < EA_AIND)
919
    {
920
#endif
921
    // flag calculation
922
    wf_op("\tres |= 0x80;\n");
923
    // write
924
    _ea_write(current_ea, current_op->reg_sft);
925
#ifndef C68K_TAS_CAN_SET_MEMORY
926
    }
927
#endif
928

929
    terminate_op(4);
930
}
931

932
static void GenTRAP()
933
{
934
    u32 base;
935

936
    base = get_current_opcode_base();
937

938
    // generate jump table
939
    gen_opjumptable_ext(base, (0 << 0), (15 << 0), (1 << 0), base);
940

941
    // generate label & declarations
942
    start_op(base, GEN_RES);
943

944
    gen_exception("\t", "C68K_TRAP_BASE_EX + (Opcode & 0xF)");
945

946
    terminate_op(4);
947
}
948

949
static void GenTRAPV()
950
{
951
    // generate label & declarations
952
    start_all(GEN_RES);
953

954
    wf_op("\tif %s\n", get_cond_as_cond(COND_VS, 0));
955
    wf_op("\t{\n");
956
        gen_exception("\t\t", "C68K_TRAPV_EX");
957
    wf_op("\t}\n");
958

959
    terminate_op(4);
960
}
961

962
static void GenLINK()
963
{
964
    current_ea = EA_AREG;
965
    set_current_size(SIZE_LONG);
966
    // generate jump table & opcode declaration
967
    start_all(GEN_RES);
968

969
    // read
970
    _ea_calc(current_ea, current_op->reg_sft);
971
    _ea_read(current_ea, current_op->reg_sft);
972
    // push
973
    mem_op("\tPUSH_32_F(res)\n");
974
    wf_op("\tres = CPU->A[7];\n");
975
    // write
976
    _ea_write(current_ea, current_op->reg_sft);
977
    // update SP
978
    wf_op("\tCPU->A[7] += (s32)(s16)FETCH_WORD;\n");
979
    wf_op("\tPC += 2;\n");
980

981
    terminate_op(16);
982
}
983

984
static void GenLINKA7()
985
{
986
    current_ea = EA_AREG;
987
    set_current_size(SIZE_LONG);
988
    // generate jump table & opcode declaration
989
    start_all(0);
990

991
    // push A7
992
    wf_op("\tCPU->A[7] -= 4;\n");
993
    mem_op("\tWRITE_LONG_DEC_F(CPU->A[7], CPU->A[7])\n");
994
    // update A7
995
    wf_op("\tCPU->A[7] += (s32)(s16)FETCH_WORD;\n");
996
    wf_op("\tPC += 2;\n");
997

998
    terminate_op(16);
999
}
1000

1001
static void GenULNK()
1002
{
1003
    current_ea = EA_AREG;
1004
    set_current_size(SIZE_LONG);
1005
    // generate jump table & opcode declaration
1006
    start_all(GEN_RES | GEN_SRC);
1007
    
1008
    // read
1009
    _ea_calc(current_ea, current_op->reg_sft);
1010
    _ea_read_src(current_ea, current_op->reg_sft);
1011
    // pop
1012
    wf_op("\tCPU->A[7] = src + 4;\n");
1013
    mem_op("\tREAD_LONG_F(src, res)\n");
1014
    // write
1015
    _ea_write(current_ea, current_op->reg_sft);
1016

1017
    terminate_op(12);
1018
}
1019

1020
static void GenULNKA7()
1021
{
1022
    current_ea = EA_AREG;
1023
    set_current_size(SIZE_LONG);
1024
    // generate jump table & opcode declaration
1025
    start_all(0);
1026

1027
    mem_op("\tREAD_LONG_F(CPU->A[7], CPU->A[7])\n");
1028
    
1029
    terminate_op(12);
1030
}
1031

1032
static void GenRESET()
1033
{
1034
    // generate jump table & opcode declaration
1035
    start_all(GEN_RES);
1036

1037
    wf_op("\tif (!CPU->flag_S)\n");
1038
    wf_op("\t{\n");
1039
        gen_privilege_exception("\t\t");
1040
        quick_terminate_op(4);
1041
    wf_op("\t}\n");
1042
    
1043
    // Reset callback function
1044
    mem_op("\tCPU->Reset_CallBack();\n");
1045

1046
    terminate_op(132);
1047
}
1048

1049
static void GenLEA()
1050
{
1051
    current_ea2 = EA_AREG;
1052
    set_current_size(SIZE_LONG);
1053
    // generate jump table & opcode declaration
1054
    start_all(GEN_ADR | GEN_RES);
1055

1056
    _ea_calc_free(current_ea, current_op->reg_sft);
1057
    wf_op("\tres = adr;\n");
1058
    current_cycle = lea_pea_cycle_table[current_ea];
1059
    _ea_calc(current_ea2, current_op->reg2_sft);
1060
    _ea_write(current_ea2, current_op->reg2_sft);
1061

1062
    terminate_op(4);
1063
}
1064

1065
static void GenNOP()
1066
{
1067
    start_all(0);
1068
    terminate_op(4);
1069
}
1070

1071
static void GenILLEGAL()
1072
{
1073
    start_all(GEN_RES);
1074

1075
    gen_exception("\t\t", "C68K_ILLEGAL_INSTRUCTION_EX");
1076
    
1077
    terminate_op(4);
1078
}
1079

1080
static void GenCHK()
1081
{
1082
    current_ea2 = EA_DREG;
1083
    set_current_size(SIZE_WORD);
1084
    // generate jump table & opcode declaration
1085
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
1086
        start_all(GEN_RES | GEN_SRC);
1087
    else
1088
        start_all(GEN_ADR | GEN_RES | GEN_SRC);
1089

1090
    // read Src
1091
    _ea_calc(current_ea, current_op->reg_sft);
1092
    _ea_read_src(current_ea, current_op->reg_sft);
1093
    // read Dx
1094
    _ea_calc(current_ea2, current_op->reg2_sft);
1095
    _ea_read(current_ea2, current_op->reg2_sft);
1096

1097
	wf_op("\tif (((s32)res < 0) || (res > src))\n");
1098
    wf_op("\t{\n");
1099
        wf_op("\t\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
1100
        gen_exception("\t\t", "C68K_CHK_EX");
1101
    wf_op("\t}\n");
1102

1103
    terminate_op(10);
1104
}
1105

1106
static void GenSTOP()
1107
{
1108
    // generate jump table & opcode declaration
1109
    start_all(GEN_RES);
1110

1111
    wf_op("\tif (!CPU->flag_S)\n");
1112
    wf_op("\t{\n");
1113
        wf_op("\t\tPC += 2;\n");
1114
        gen_privilege_exception("\t\t");
1115
        quick_terminate_op(4);
1116
    wf_op("\t}\n");
1117

1118
    // read & set SR
1119
    wf_op("\tres = FETCH_WORD & C68K_SR_MASK;\n");
1120
    wf_op("\tPC += 2;\n");
1121
    wf_op("\tSET_SR(res)\n");
1122

1123
    // if S flag not set --> we swap stack pointer
1124
    wf_op("\tif (!CPU->flag_S)\n");
1125
    wf_op("\t{\n");
1126
        wf_op("\t\tres = CPU->A[7];\n");
1127
        wf_op("\t\tCPU->A[7] = CPU->USP;\n");
1128
        wf_op("\t\tCPU->USP = res;\n");
1129
    wf_op("\t}\n");
1130

1131
    wf_op("\tCPU->Status |= C68K_HALTED;\n");
1132
    wf_op("\tCCnt = 0;\n");
1133
    
1134
    // force end execution
1135
    fterminate_op(4);
1136
}
1137

1138
static void GenRTE()
1139
{
1140
    start_all(GEN_RES);
1141

1142
    wf_op("\tif (!CPU->flag_S)\n");
1143
    wf_op("\t{\n");
1144
        gen_privilege_exception("\t\t");
1145
        quick_terminate_op(4);
1146
    wf_op("\t}\n");
1147

1148
    // restore SR and PC
1149
    mem_op("\tPOP_16_F(res)\n");
1150
    wf_op("\tSET_SR(res)\n");
1151
    mem_op("\tPOP_32_F(res)\n");
1152
    wf_op("\tSET_PC(res)\n");
1153

1154
    // if S flag not set --> we swap stack pointer
1155
    wf_op("\tif (!CPU->flag_S)\n");
1156
    wf_op("\t{\n");
1157
        wf_op("\t\tres = CPU->A[7];\n");
1158
        wf_op("\t\tCPU->A[7] = CPU->USP;\n");
1159
        wf_op("\t\tCPU->USP = res;\n");
1160
    wf_op("\t}\n");
1161

1162
    // check for interrupt
1163
    fterminate_op(20);
1164
}
1165

1166
static void GenRTS()
1167
{
1168
    start_all(GEN_RES);
1169

1170
    mem_op("\tPOP_32_F(res)\n");
1171
    wf_op("\tSET_PC(res)\n");
1172

1173
    terminate_op(16);
1174
}
1175

1176
static void GenRTR()
1177
{
1178
    start_all(GEN_RES);
1179

1180
    mem_op("\tPOP_16_F(res)\n");
1181
    wf_op("\tSET_CCR(res)\n");
1182
    mem_op("\tPOP_32_F(res)\n");
1183
    wf_op("\tSET_PC(res)\n");
1184

1185
    terminate_op(20);
1186
}
1187

1188
static void GenJSR()
1189
{
1190
    start_all(GEN_ADR);
1191
    
1192
    // get adr
1193
    _ea_calc_free(current_ea, current_op->reg_sft);
1194
    mem_op("\tPUSH_32_F(PC - CPU->BasePC)\n");
1195
    wf_op("\tSET_PC(adr)\n");
1196
    
1197
    terminate_op(jmp_jsr_cycle_table[current_ea] + 12);
1198
}
1199

1200
static void GenJMP()
1201
{
1202
    start_all(GEN_ADR);
1203

1204
    // get adr
1205
    _ea_calc_free(current_ea, current_op->reg_sft);
1206
    wf_op("\tSET_PC(adr)\n");
1207

1208
    terminate_op(jmp_jsr_cycle_table[current_ea] + 4);
1209
}
1210

1211
static void GenSTCC()
1212
{
1213
    u32 base, cond;
1214
    
1215
    base = get_current_opcode_base();
1216
    
1217
    for(cond = 0; cond < 0x10; cond++)
1218
    {
1219
        // generate jump table
1220
        gen_opjumptable(base + (cond << 8));
1221
        // generate label & declarations
1222
        if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
1223
            start_op(base + (cond << 8), GEN_RES);
1224
        else
1225
            start_op(base + (cond << 8), GEN_ADR | GEN_RES);
1226
        
1227
        set_current_size(SIZE_BYTE);
1228

1229
        if (is_ea_memory(current_ea)) current_cycle += 4;
1230
        
1231
        // op
1232
        _ea_calc(current_ea, current_op->reg_sft);
1233
        if ((cond != COND_TR) && (cond != COND_FA))
1234
        {
1235
            wf_op("\tif %s\n", get_cond_as_cond(cond, 0));
1236
            wf_op("\t{\n");
1237
        }
1238
        if (cond != COND_FA)
1239
        {
1240
            wf_op("\tres = 0xFF;\n");
1241
            // write
1242
            _ea_write(current_ea, current_op->reg_sft);
1243
            if (!is_ea_memory(current_ea)) quick_terminate_op(6);
1244
            else quick_terminate_op(4);
1245
        }
1246
        if ((cond != COND_TR) && (cond != COND_FA))
1247
        {
1248
            wf_op("\t}\n");
1249
        }
1250
        if (cond != COND_TR)
1251
        {
1252
            wf_op("\tres = 0;\n");
1253
            // write
1254
            _ea_write(current_ea, current_op->reg_sft);
1255
            quick_terminate_op(4);
1256
        }
1257

1258
        wf_op("}\n");
1259
    }
1260
}
1261

1262
static void GenDBCC()
1263
{
1264
    u32 base, cond;
1265

1266
    base = get_current_opcode_base();
1267
    
1268
    current_ea = EA_DREG;
1269
    set_current_size(SIZE_WORD);
1270

1271
    for(cond = 0; cond < 0x10; cond++)
1272
    {
1273
        // generate jump table
1274
        gen_opjumptable(base + (cond << 8));
1275
        // generate label & declarations
1276
        start_op(base + (cond << 8), cond==COND_TR ? 0 : GEN_RES);
1277
        
1278
        if (cond != COND_TR)
1279
        {
1280
            if (cond != COND_FA)
1281
            {
1282
                wf_op("\tif %s\n", get_cond_as_cond(cond, 1));
1283
                wf_op("\t{\n");
1284
            }
1285
            
1286
            // read Dx
1287
            _ea_calc(current_ea, current_op->reg_sft);
1288
            _ea_read(current_ea, current_op->reg_sft);
1289
            // dec Dx
1290
            wf_op("\tres--;\n");
1291
            // write Dx
1292
            _ea_write(current_ea, current_op->reg_sft);
1293
            wf_op("\tif ((s32)res != -1)\n");
1294
            wf_op("\t{\n");
1295
                wf_op("\t\tPC += (s32)(s16)FETCH_WORD;\n");
1296
                // unbase PC
1297
                wf_op("\t\tPC -= CPU->BasePC;\n");
1298
                // rebase PC
1299
                wf_op("\t\tSET_PC(PC);\n");
1300
                quick_terminate_op(10);
1301
            wf_op("\t}\n");
1302

1303
            if (cond != COND_FA)
1304
            {
1305
                wf_op("\t}\n");
1306
                wf_op("\telse\n");
1307
                wf_op("\t{\n");
1308
                    wf_op("\t\tPC += 2;\n");
1309
                    quick_terminate_op(12);
1310
                wf_op("\t}\n");
1311
            }
1312
        }
1313
        
1314
        wf_op("\tPC += 2;\n");
1315
        
1316
        if (cond == COND_TR) terminate_op(12);
1317
        else terminate_op(14);
1318
    }
1319
}
1320

1321
static void GenBCC()
1322
{
1323
    u32 base, cond;
1324

1325
    base = get_current_opcode_base();
1326
    
1327
    for(cond = 2; cond < 0x10; cond++)
1328
    {
1329
        // generate jump table
1330
        gen_opjumptable_ext(base + (cond << 8), 0x01, 0xFF, 1, base + (cond << 8) + 0x01);
1331
        // generate label & declarations
1332
        start_op(base + (cond << 8) + 0x01, 0);
1333

1334
        // op
1335
        wf_op("\tif %s\n", get_cond_as_cond(cond, 0));
1336
        wf_op("\t{\n");
1337
            wf_op("\t\tPC += (s32)(s8)Opcode;\n");     // no rebase needed for 8 bits deplacement
1338
            add_CCnt(2);
1339
        wf_op("\t}\n");
1340

1341
        terminate_op(8);
1342
    }
1343
}
1344

1345
static void GenBCC16()
1346
{
1347
    u32 base, cond;
1348

1349
    base = get_current_opcode_base();
1350

1351
    for(cond = 2; cond < 0x10; cond++)
1352
    {
1353
        // generate jump table
1354
        gen_opjumptable(base + (cond << 8));
1355
        // generate label & declarations
1356
        start_op(base + (cond << 8), 0);
1357

1358
        // op
1359
        wf_op("\tif %s\n", get_cond_as_cond(cond, 0));
1360
        wf_op("\t{\n");
1361
            wf_op("\t\tPC += (s32)(s16)FETCH_WORD;\n");
1362
            // unbase PC
1363
            wf_op("\t\tPC -= CPU->BasePC;\n");
1364
            // rebase PC
1365
            wf_op("\t\tSET_PC(PC);\n");
1366
            quick_terminate_op(10);
1367
        wf_op("\t}\n");
1368
        
1369
        wf_op("\tPC += 2;\n");
1370

1371
        terminate_op(12);
1372
    }
1373
}
1374

1375
static void GenBRA()
1376
{
1377
    u32 base = get_current_opcode_base();
1378

1379
    // generate jump table
1380
    gen_opjumptable_ext(base, 0x01, 0xFF, 1, base + 0x01);
1381
    // generate label & declarations
1382
    start_op(base + 0x01, 0);
1383

1384
    wf_op("\tPC += (s32)(s8)Opcode;\n");     // no rebase needed for 8 bits deplacement
1385

1386
    terminate_op(10);
1387
}
1388

1389
static void GenBRA16()
1390
{
1391
    u32 base = get_current_opcode_base();
1392

1393
    // generate jump table
1394
    gen_opjumptable(base + 0x00);
1395
    // generate label & declarations
1396
    start_op(base + 0x00, 0);
1397

1398
    wf_op("\tPC += (s32)(s16)FETCH_WORD;\n");
1399
    // unbase PC
1400
    wf_op("\tPC -= CPU->BasePC;\n");
1401
    // rebase PC
1402
    wf_op("\tSET_PC(PC);\n");
1403

1404
    terminate_op(10);
1405
}
1406

1407
static void GenBSR()
1408
{
1409
    u32 base = get_current_opcode_base();
1410

1411
    // generate jump table
1412
    gen_opjumptable_ext(base, 0x01, 0xFF, 1, base + 0x01);
1413
    // generate label & declarations
1414
    start_op(base + 0x01, 0);
1415

1416
    mem_op("\tPUSH_32_F(PC - CPU->BasePC)\n");
1417
    wf_op("\tPC += (s32)(s8)Opcode;\n");     // no rebase needed for 8 bits deplacement
1418

1419
    terminate_op(18);
1420
}
1421

1422
static void GenBSR16()
1423
{
1424
    u32 base = get_current_opcode_base();
1425

1426
    // generate jump table
1427
    gen_opjumptable(base + 0x00);
1428
    // generate label & declarations
1429
    start_op(base + 0x00, GEN_RES);
1430

1431
    wf_op("\tres = (s32)(s16)FETCH_WORD;\n");
1432
    // unbase PC
1433
    wf_op("\tPC -= CPU->BasePC;\n");
1434
    mem_op("\tPUSH_32_F(PC + 2)\n");
1435
    wf_op("\tPC += (s32) res;\n");
1436
    // rebase PC for 16 bits deplacement
1437
    wf_op("\tSET_PC(PC);\n");
1438

1439
    terminate_op(18);
1440
}
1441

1442
static void GenArithQ(char op)
1443
{
1444
    u32 base;
1445

1446
    if ((current_ea == EA_AREG) && (current_size == SIZE_BYTE)) return;
1447

1448
    base = get_current_opcode_base();
1449
    
1450
    // generate jump table
1451
    gen_opjumptable_ext(base, (0 << 9), (7 << 9), (1 << 9), base);
1452

1453
    // generate label & declarations
1454
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
1455
        start_op(base, GEN_DST | GEN_RES | GEN_SRC);
1456
    else
1457
        start_op(base, GEN_ALL);
1458

1459
    if (current_ea == EA_AREG) set_current_size(SIZE_LONG);
1460

1461
    if (is_ea_memory(current_ea)) current_cycle += 4;
1462
    if (current_size == SIZE_LONG) current_cycle += 4;
1463

1464
    // read src
1465
	wf_op("\tsrc = (((Opcode >> 9) - 1) & 7) + 1;\n");
1466
    // read dst
1467
    _ea_calc(current_ea, current_op->reg_sft);
1468
    _ea_read_dst(current_ea, current_op->reg_sft);
1469
    // op
1470
    wf_op("\tres = dst %c src;\n", op);
1471
    // flag calculation
1472
    if (current_ea != EA_AREG)
1473
    {
1474
        if (op == '+') set_add_flag();
1475
        else set_sub_flag();
1476
    }
1477
    // write dst
1478
    _ea_write(current_ea, current_op->reg_sft);
1479

1480
    terminate_op(4);
1481
}
1482

1483
static void GenADDQ()
1484
{
1485
    GenArithQ('+');
1486
}
1487

1488
static void GenSUBQ()
1489
{
1490
    GenArithQ('-');
1491
}
1492

1493
static void GenLogicaD(char op)
1494
{
1495
    // generate jump table & opcode declaration
1496
    current_ea2 = EA_DREG;
1497
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
1498
        start_all(GEN_RES | GEN_SRC);
1499
    else
1500
        start_all(GEN_ADR | GEN_RES | GEN_SRC);
1501

1502
    if (current_size == SIZE_LONG)
1503
    {
1504
        if (!is_ea_memory(current_ea)) current_cycle += 2;
1505
        else current_cycle += 4;
1506
    }
1507

1508
    // read src
1509
    _ea_calc(current_ea, current_op->reg_sft);
1510
    _ea_read_src(current_ea, current_op->reg_sft);
1511
    // read dst (Dx)
1512
    _ea_calc(current_ea2, current_op->reg2_sft);
1513
    _ea_read(current_ea2, current_op->reg2_sft);
1514
    // op
1515
    wf_op("\tres %c= src;\n", op);
1516
    // flag calculation
1517
    set_logic_flag();
1518
    // write dst (Dx)
1519
    _ea_write(current_ea2, current_op->reg2_sft);
1520

1521
    terminate_op(4);
1522
}
1523

1524
static void GenLogicDa(char op)
1525
{
1526
    // generate jump table & opcode declaration
1527
    current_ea2 = EA_DREG;
1528
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
1529
        start_all(GEN_RES | GEN_SRC);
1530
    else
1531
        start_all(GEN_ADR | GEN_RES | GEN_SRC);
1532

1533
    if (current_size == SIZE_LONG) current_cycle += 4;
1534

1535
    // read src (Dx)
1536
    _ea_calc(current_ea2, current_op->reg2_sft);
1537
    _ea_read_src(current_ea2, current_op->reg2_sft);
1538
    // read dst
1539
    _ea_calc(current_ea, current_op->reg_sft);
1540
    _ea_read(current_ea, current_op->reg_sft);
1541
    // op
1542
    wf_op("\tres %c= src;\n", op);
1543
    // flag calculation
1544
    set_logic_flag();
1545
    // write dst
1546
    _ea_write(current_ea, current_op->reg_sft);
1547

1548
    if (current_ea == EA_DREG) terminate_op(4);
1549
    else terminate_op(8);
1550
}
1551

1552
static void GenANDaD()
1553
{
1554
    GenLogicaD('&');
1555
}
1556

1557
static void GenANDDa()
1558
{
1559
    GenLogicDa('&');
1560
}
1561

1562
static void GenORaD()
1563
{
1564
    GenLogicaD('|');
1565
}
1566

1567
static void GenORDa()
1568
{
1569
    GenLogicDa('|');
1570
}
1571

1572
static void GenEORDa()
1573
{
1574
    GenLogicDa('^');
1575
}
1576

1577
static void GenNBCD()
1578
{
1579
    set_current_size(SIZE_BYTE);
1580

1581
    // generate jump table & opcode declaration
1582
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
1583
        start_all(GEN_RES);
1584
    else
1585
        start_all(GEN_ADR | GEN_RES);
1586

1587
    if (is_ea_memory(current_ea)) current_cycle += 2;
1588

1589
    // read
1590
    _ea_calc(current_ea, current_op->reg_sft);
1591
    _ea_read(current_ea, current_op->reg_sft);
1592
    
1593
	// op
1594
    wf_op("\tres = 0x9a - res - ((CPU->flag_X >> C68K_SR_X_SFT) & 1);\n");
1595
    wf_op("\n");
1596
    wf_op("\tif (res != 0x9a)\n");
1597
    wf_op("\t{\n");
1598
        wf_op("\t\tif ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;\n");
1599
        wf_op("\t\tres &= 0xFF;\n");
1600

1601
        // write
1602
        _ea_write(current_ea, current_op->reg_sft);
1603

1604
        // flag calculation
1605
       	wf_op("\t\tCPU->flag_notZ |= res;\n");
1606
        wf_op("\t\tCPU->flag_X = CPU->flag_C = C68K_SR_C;\n");
1607

1608
    wf_op("\t}\n");
1609
    wf_op("\telse CPU->flag_X = CPU->flag_C = 0;\n");
1610
   	wf_op("\tCPU->flag_N = res;\n");
1611

1612
    terminate_op(6);
1613
}
1614

1615
static void GenBCD(char op)
1616
{
1617
    // op
1618
    wf_op("\tres = (dst & 0xF) %c (src & 0xF) %c ((CPU->flag_X >> C68K_SR_X_SFT) & 1);\n", op, op);
1619
    wf_op("\tif (res > 9) res %c= 6;\n", op);
1620
    wf_op("\tres += (dst & 0xF0) %c (src & 0xF0);\n", op, op);
1621

1622
    // flag calculation
1623
    wf_op("\tif (res > 0x99)\n");
1624
    wf_op("\t{\n");
1625
        switch (op)
1626
        {
1627
            case '+':
1628
                wf_op("\t\tres -= 0xA0;\n");
1629
                break;
1630

1631
            case '-':
1632
                wf_op("\t\tres += 0xA0;\n");
1633
                break;
1634
        }
1635
        wf_op("\t\tCPU->flag_X = CPU->flag_C = C68K_SR_C;\n");
1636
    wf_op("\t}\n");
1637
    wf_op("\telse CPU->flag_X = CPU->flag_C = 0;\n");
1638
   	wf_op("\tCPU->flag_notZ |= res & 0xFF;\n");
1639
   	wf_op("\tCPU->flag_N = res;\n");
1640
}
1641

1642
static void GenxBCD(char op)
1643
{
1644
    set_current_size(SIZE_BYTE);
1645

1646
    // generate jump table & opcode declaration
1647
    current_ea = EA_DREG;
1648
    current_ea2 = EA_DREG;
1649
    start_all(GEN_DST | GEN_RES | GEN_SRC);
1650

1651
    // read src (Dx)
1652
    _ea_calc(current_ea, current_op->reg_sft);
1653
    _ea_read_src(current_ea, current_op->reg_sft);
1654
    // read dst (Dx)
1655
    _ea_calc(current_ea2, current_op->reg2_sft);
1656
    _ea_read_dst(current_ea2, current_op->reg2_sft);
1657
    
1658
    // op & flag calculation
1659
    GenBCD(op);
1660

1661
    // write dst (Dx)
1662
    _ea_write(current_ea2, current_op->reg2_sft);
1663

1664
    terminate_op(6);
1665
}
1666

1667
static void GenxBCDM(char op)
1668
{
1669
    set_current_size(SIZE_BYTE);
1670

1671
    // generate jump table & opcode declaration
1672
    current_ea = EA_ADEC;
1673
    current_ea2 = EA_ADEC;
1674
    start_all(GEN_ALL);
1675

1676
    // read src (ADEC)
1677
    _ea_calc(current_ea, current_op->reg_sft);
1678
    _ea_read_src(current_ea, current_op->reg_sft);
1679
    // read dst (ADEC)
1680
    _ea_calc(current_ea2, current_op->reg2_sft);
1681
    _ea_read_dst(current_ea2, current_op->reg2_sft);
1682
    
1683
    // op & flag calculation
1684
    GenBCD(op);
1685

1686
    // write dst (ADEC)
1687
    _ea_write(current_ea2, current_op->reg2_sft);
1688

1689
    terminate_op(6);
1690
}
1691

1692
static void GenxBCD7M(char op)
1693
{
1694
    set_current_size(SIZE_BYTE);
1695

1696
    // generate jump table & opcode declaration
1697
    current_ea = EA_ADEC7;
1698
    current_ea2 = EA_ADEC;
1699
    start_all(GEN_ALL);
1700

1701
    // read src (ADEC7)
1702
    _ea_calc(current_ea, 0);
1703
    _ea_read_src(current_ea, 0);
1704
    // read dst (ADEC)
1705
    _ea_calc(current_ea2, current_op->reg2_sft);
1706
    _ea_read_dst(current_ea2, current_op->reg2_sft);
1707

1708
    // op & flag calculation
1709
    GenBCD(op);
1710

1711
    // write dst (ADEC)
1712
    _ea_write(current_ea2, current_op->reg2_sft);
1713

1714
    terminate_op(6);
1715
}
1716

1717
static void GenxBCDM7(char op)
1718
{
1719
    set_current_size(SIZE_BYTE);
1720

1721
    // generate jump table & opcode declaration
1722
    current_ea = EA_ADEC;
1723
    current_ea2 = EA_ADEC7;
1724
    start_all(GEN_ALL);
1725

1726
    // read src (ADEC)
1727
    _ea_calc(current_ea, current_op->reg_sft);
1728
    _ea_read_src(current_ea, current_op->reg_sft);
1729
    // read dst (ADEC7)
1730
    _ea_calc(current_ea2, 0);
1731
    _ea_read_dst(current_ea2, 0);
1732

1733
    // op & flag calculation
1734
    GenBCD(op);
1735

1736
    // write dst (ADEC7)
1737
    _ea_write(current_ea2, 0);
1738

1739
    terminate_op(6);
1740
}
1741

1742
static void GenxBCD7M7(char op)
1743
{
1744
    set_current_size(SIZE_BYTE);
1745

1746
    // generate jump table & opcode declaration
1747
    current_ea = EA_ADEC7;
1748
    current_ea2 = EA_ADEC7;
1749
    start_all(GEN_ALL);
1750

1751
    // read src (ADEC7)
1752
    _ea_calc(current_ea, 0);
1753
    _ea_read_src(current_ea, 0);
1754
    // read dst (ADEC7)
1755
    _ea_calc(current_ea2, 0);
1756
    _ea_read_dst(current_ea2, 0);
1757

1758
    // op & flag calculation
1759
    GenBCD(op);
1760

1761
    // write dst (ADEC7)
1762
    _ea_write(current_ea2, 0);
1763

1764
    terminate_op(6);
1765
}
1766

1767
static void GenABCD()
1768
{
1769
    GenxBCD('+');
1770
}
1771

1772
static void GenABCDM()
1773
{
1774
    GenxBCDM('+');
1775
}
1776

1777
static void GenABCD7M()
1778
{
1779
    GenxBCD7M('+');
1780
}
1781

1782
static void GenABCDM7()
1783
{
1784
    GenxBCDM7('+');
1785
}
1786

1787
static void GenABCD7M7()
1788
{
1789
    GenxBCD7M7('+');
1790
}
1791

1792
static void GenSBCD()
1793
{
1794
    GenxBCD('-');
1795
}
1796

1797
static void GenSBCDM()
1798
{
1799
    GenxBCDM('-');
1800
}
1801

1802
static void GenSBCD7M()
1803
{
1804
    GenxBCD7M('-');
1805
}
1806

1807
static void GenSBCDM7()
1808
{
1809
    GenxBCDM7('-');
1810
}
1811

1812
static void GenSBCD7M7()
1813
{
1814
    GenxBCD7M7('-');
1815
}
1816

1817
static void GenDIVU()
1818
{
1819
    // generate jump table & opcode declaration
1820
    current_ea2 = EA_DREG;
1821
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
1822
        start_all(GEN_DST | GEN_RES | GEN_SRC);
1823
    else
1824
        start_all(GEN_ALL);
1825

1826
    set_current_size(SIZE_WORD);
1827
    
1828
    // read src
1829
    _ea_calc(current_ea, current_op->reg_sft);
1830
    _ea_read_src(current_ea, current_op->reg_sft);
1831
    
1832
    // division by zero
1833
    wf_op("\tif (src == 0)\n");
1834
    wf_op("\t{\n");
1835
        gen_exception("\t\t", "C68K_ZERO_DIVIDE_EX");
1836
        quick_terminate_op(10);
1837
    wf_op("\t}\n");
1838
    
1839
    set_current_size(SIZE_LONG);
1840

1841
    // read dst (Dx)
1842
    _ea_calc(current_ea2, current_op->reg2_sft);
1843
    _ea_read_dst(current_ea2, current_op->reg2_sft);
1844

1845
    wf_op("\t{\n");
1846
        wf_op("\t\tu32 q, r;\n");
1847
        wf_op("\n");
1848
        wf_op("\t\tq = dst / src;\n");
1849
        wf_op("\t\tr = dst %% src;\n");
1850
        wf_op("\n");
1851
        
1852
        wf_op("\t\tif (q & 0xFFFF0000)\n");
1853
        wf_op("\t\t{\n");
1854
            // overflow occured
1855
            wf_op("\t\t\tCPU->flag_V = C68K_SR_V;\n");
1856
            quick_terminate_op(70);
1857
        wf_op("\t\t}\n");
1858
        
1859
        // quotient size = word
1860
        set_current_size(SIZE_WORD);
1861

1862
        wf_op("\t\tq &= 0x%.8X;\n", current_bits_mask);
1863
        wf_op("\t\tCPU->flag_notZ = q;\n");
1864
        wf_op("\t\tCPU->flag_N = q >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
1865
        wf_op("\t\tCPU->flag_V = CPU->flag_C = 0;\n");
1866

1867
        wf_op("\t\tres = q | (r << 16);\n");
1868
        
1869
        set_current_size(SIZE_LONG);
1870

1871
        // write dst (Dx)
1872
        _ea_write(current_ea2, current_op->reg2_sft);
1873
    wf_op("\t}\n");
1874

1875
    // max cycle = 140
1876
    terminate_op(140 - 50);
1877
}
1878

1879
static void GenDIVS()
1880
{
1881
    // generate jump table & opcode declaration
1882
    current_ea2 = EA_DREG;
1883
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
1884
        start_all(GEN_DST | GEN_RES | GEN_SRC);
1885
    else
1886
        start_all(GEN_ALL);
1887

1888
    set_current_size(SIZE_WORD);
1889

1890
    // read src
1891
    _ea_calc(current_ea, current_op->reg_sft);
1892
    _ea_read_src_sx(current_ea, current_op->reg_sft);
1893

1894
    // division by zero
1895
    wf_op("\tif (src == 0)\n");
1896
    wf_op("\t{\n");
1897
        gen_exception("\t\t", "C68K_ZERO_DIVIDE_EX");
1898
        quick_terminate_op(10);
1899
    wf_op("\t}\n");
1900

1901
    set_current_size(SIZE_LONG);
1902

1903
    // read dst (Dx)
1904
    _ea_calc(current_ea2, current_op->reg2_sft);
1905
    _ea_read_dst(current_ea2, current_op->reg2_sft);
1906

1907
    // division by zero
1908
    wf_op("\tif ((dst == 0x80000000) && (src == -1))\n");
1909
    wf_op("\t{\n");
1910
        wf_op("\t\tCPU->flag_notZ = CPU->flag_N = 0;\n");
1911
        wf_op("\t\tCPU->flag_V = CPU->flag_C = 0;\n");
1912
        wf_op("\t\tres = 0;\n");
1913

1914
        // write dst (Dx)
1915
        _ea_write(current_ea2, current_op->reg2_sft);
1916

1917
        quick_terminate_op(50);
1918
    wf_op("\t}\n");
1919

1920
    wf_op("\t{\n");
1921
        wf_op("\t\ts32 q, r;\n");
1922
        wf_op("\n");
1923
        wf_op("\t\tq = (s32)dst / (s32)src;\n");
1924
        wf_op("\t\tr = (s32)dst %% (s32)src;\n");
1925
        wf_op("\n");
1926

1927
        wf_op("\t\tif ((q > 0x7FFF) || (q < -0x8000))\n");
1928
        wf_op("\t\t{\n");
1929
            // overflow occured
1930
            wf_op("\t\t\tCPU->flag_V = C68K_SR_V;\n");
1931
            quick_terminate_op(80);
1932
        wf_op("\t\t}\n");
1933

1934
        // quotient size = word
1935
        set_current_size(SIZE_WORD);
1936
        
1937
        wf_op("\t\tq &= 0x%.8X;\n", current_bits_mask);
1938
        wf_op("\t\tCPU->flag_notZ = q;\n");
1939
        wf_op("\t\tCPU->flag_N = q >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
1940
        wf_op("\t\tCPU->flag_V = CPU->flag_C = 0;\n");
1941

1942
        wf_op("\t\tres = q | (r << 16);\n");
1943

1944
        set_current_size(SIZE_LONG);
1945

1946
        // write dst (Dx)
1947
        _ea_write(current_ea2, current_op->reg2_sft);
1948
    wf_op("\t}\n");
1949

1950
    // max cycle = 158
1951
    terminate_op(158 - 50);
1952
}
1953

1954
static void GenMULU()
1955
{
1956
    // generate jump table & opcode declaration
1957
    current_ea2 = EA_DREG;
1958
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
1959
        start_all(GEN_RES | GEN_SRC);
1960
    else
1961
        start_all(GEN_ADR | GEN_RES | GEN_SRC);
1962

1963
    set_current_size(SIZE_WORD);
1964

1965
    // read src
1966
    _ea_calc(current_ea, current_op->reg_sft);
1967
    _ea_read_src(current_ea, current_op->reg_sft);
1968
    // read dst (Dx)
1969
    _ea_calc(current_ea2, current_op->reg2_sft);
1970
    _ea_read(current_ea2, current_op->reg2_sft);
1971

1972
    set_current_size(SIZE_LONG);
1973
    // op
1974
    wf_op("\tres *= src;\n");
1975

1976
    // flag calculation
1977
   	wf_op("\tCPU->flag_N = res >> 24;\n");
1978
   	wf_op("\tCPU->flag_notZ = res;\n");
1979
    wf_op("\tCPU->flag_V = CPU->flag_C = 0;\n");
1980

1981
    // write dst (Dx)
1982
    _ea_write(current_ea2, current_op->reg2_sft);
1983

1984
    // min cycle = 38; max cycle = 70
1985
    terminate_op(38 + (2 * 6));
1986
}
1987

1988
static void GenMULS()
1989
{
1990
    // generate jump table & opcode declaration
1991
    current_ea2 = EA_DREG;
1992
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
1993
        start_all(GEN_RES | GEN_SRC);
1994
    else
1995
        start_all(GEN_ADR | GEN_RES | GEN_SRC);
1996

1997
    set_current_size(SIZE_WORD);
1998
    // read src signed
1999
    _ea_calc(current_ea, current_op->reg_sft);
2000
    _ea_read_src_sx(current_ea, current_op->reg_sft);
2001
    // read dst signed (Dx)
2002
    _ea_calc(current_ea2, current_op->reg2_sft);
2003
    _ea_read_sx(current_ea2, current_op->reg2_sft);
2004
    
2005
    set_current_size(SIZE_LONG);
2006
    // op
2007
    //wf_op("\t(s32)res *= (s32)src;\n");
2008
    wf_op("\tres *= (s32)src;\n"); // antime fix
2009
    
2010
    // flag calculation
2011
   	wf_op("\tCPU->flag_N = res >> 24;\n");
2012
   	wf_op("\tCPU->flag_notZ = res;\n");
2013
    wf_op("\tCPU->flag_V = CPU->flag_C = 0;\n");
2014
    
2015
    // write dst (Dx)
2016
    _ea_write(current_ea2, current_op->reg2_sft);
2017

2018
    // min cycle = 38; max cycle = 70
2019
    terminate_op(38 + (2 * 6));
2020
}
2021

2022
static void GenArithaD(char op)
2023
{
2024
    // generate jump table & opcode declaration
2025
    current_ea2 = EA_DREG;
2026
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
2027
        start_all(GEN_DST | GEN_RES | GEN_SRC);
2028
    else
2029
        start_all(GEN_ALL);
2030

2031
    if (current_size == SIZE_LONG)
2032
    {
2033
        if (!is_ea_memory(current_ea)) current_cycle += 2;
2034
        else current_cycle += 4;
2035
    }
2036

2037
    // read src
2038
    _ea_calc(current_ea, current_op->reg_sft);
2039
    _ea_read_src(current_ea, current_op->reg_sft);
2040
    // read dst (Dx)
2041
    _ea_calc(current_ea2, current_op->reg2_sft);
2042
    _ea_read_dst(current_ea2, current_op->reg2_sft);
2043
    if (op == ' ')
2044
    {
2045
        // op
2046
        wf_op("\tres = dst - src;\n");
2047
        // flag calculation
2048
        set_cmp_flag();
2049
    }
2050
    else
2051
    {
2052
        // op
2053
        wf_op("\tres = dst %c src;\n", op);
2054
        // flag calculation
2055
        if (op == '+') set_add_flag();
2056
        else set_sub_flag();
2057
        // write dst (Dx)
2058
        _ea_write(current_ea2, current_op->reg2_sft);
2059
    }
2060

2061
    terminate_op(4);
2062
}
2063

2064
static void GenArithDa(char op)
2065
{
2066
    // generate jump table & opcode declaration
2067
    current_ea2 = EA_DREG;
2068
    start_all(GEN_ALL);
2069

2070
    if (current_size == SIZE_LONG) current_cycle += 4;
2071

2072
    // read src (Dx)
2073
    _ea_calc(current_ea2, current_op->reg2_sft);
2074
    _ea_read_src(current_ea2, current_op->reg2_sft);
2075
    // read dst
2076
    _ea_calc(current_ea, current_op->reg_sft);
2077
    _ea_read_dst(current_ea, current_op->reg_sft);
2078
    // op
2079
    wf_op("\tres = dst %c src;\n", op);
2080
    // flag calculation
2081
    if (op == '+') set_add_flag();
2082
    else set_sub_flag();
2083
    // write dst
2084
    _ea_write(current_ea, current_op->reg_sft);
2085

2086
    terminate_op(8);
2087
}
2088

2089
static void GenArithA(char op)
2090
{
2091
    // generate jump table & opcode declaration
2092
    current_ea2 = EA_AREG;
2093
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
2094
        start_all(GEN_DST | GEN_RES | GEN_SRC);
2095
    else
2096
        start_all(GEN_ALL);
2097

2098
    if ((op != ' ') && ((current_size == SIZE_WORD) || (is_ea_memory(current_ea)))) current_cycle += 2;
2099

2100
    // read src
2101
    _ea_calc(current_ea, current_op->reg_sft);
2102
    _ea_read_src_sx(current_ea, current_op->reg_sft);
2103
    // read dst (Ax)
2104
    set_current_size(SIZE_LONG);
2105
    _ea_calc(current_ea2, current_op->reg2_sft);
2106
    _ea_read_dst(current_ea2, current_op->reg2_sft);
2107
    // op
2108
    if (op == ' ')
2109
    {
2110
        // op
2111
        wf_op("\tres = dst - src;\n");
2112
        // flag calculation
2113
        set_cmp_flag();
2114
    }
2115
    else
2116
    {
2117
        // op
2118
        wf_op("\tres = dst %c src;\n", op);
2119
        // write dst (Ax)
2120
        _ea_write(current_ea2, current_op->reg2_sft);
2121
    }
2122

2123
    terminate_op(6);
2124
}
2125

2126
static void GenArithX(char op)
2127
{
2128
    // generate jump table & opcode declaration
2129
    current_ea = EA_DREG;
2130
    current_ea2 = EA_DREG;
2131
    if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM))
2132
        start_all(GEN_DST | GEN_RES | GEN_SRC);
2133
    else
2134
        start_all(GEN_ALL);
2135

2136
    if (current_size == SIZE_LONG) current_cycle += 4;
2137

2138
    // read src (Dx)
2139
    _ea_calc(current_ea, current_op->reg_sft);
2140
    _ea_read_src(current_ea, current_op->reg_sft);
2141
    // read dst (Dx)
2142
    _ea_calc(current_ea2, current_op->reg2_sft);
2143
    _ea_read_dst(current_ea2, current_op->reg2_sft);
2144
    // op
2145
    wf_op("\tres = dst %c src %c ((CPU->flag_X >> 8) & 1);\n", op, op);
2146
    // flag calculation
2147
    if (op == '+') set_addx_flag();
2148
    else set_subx_flag();
2149
    // write dst (Dx)
2150
    _ea_write(current_ea2, current_op->reg2_sft);
2151

2152
    terminate_op(4);
2153
}
2154

2155
static void GenArithXM(char op)
2156
{
2157
    // generate jump table & opcode declaration
2158
    current_ea = EA_ADEC;
2159
    current_ea2 = EA_ADEC;
2160
    start_all(GEN_ALL);
2161

2162
    if (current_size == SIZE_LONG) current_cycle += 4;
2163

2164
    // read src (ADEC)
2165
    _ea_calc(current_ea, current_op->reg_sft);
2166
    _ea_read_src(current_ea, current_op->reg_sft);
2167
    // read dst (ADEC)
2168
    _ea_calc(current_ea2, current_op->reg2_sft);
2169
    _ea_read_dst(current_ea2, current_op->reg2_sft);
2170
    // op
2171
    wf_op("\tres = dst %c src %c ((CPU->flag_X >> 8) & 1);\n", op, op);
2172
    // flag calculation
2173
    if (op == '+') set_addx_flag();
2174
    else set_subx_flag();
2175
    // write dst (ADEC)
2176
    _ea_write(current_ea2, current_op->reg2_sft);
2177

2178
    terminate_op(6);
2179
}
2180

2181
static void GenArithX7M(char op)
2182
{
2183
    // generate jump table & opcode declaration
2184
    current_ea = EA_ADEC7;
2185
    current_ea2 = EA_ADEC;
2186
    start_all(GEN_ALL);
2187

2188
    if (current_size == SIZE_LONG) current_cycle += 4;
2189

2190
    // read src (ADEC7)
2191
    _ea_calc(current_ea, 0);
2192
    _ea_read_src(current_ea, 0);
2193
    // read dst (ADEC)
2194
    _ea_calc(current_ea2, current_op->reg2_sft);
2195
    _ea_read_dst(current_ea2, current_op->reg2_sft);
2196
    // op
2197
    wf_op("\tres = dst %c src %c ((CPU->flag_X >> 8) & 1);\n", op, op);
2198
    // flag calculation
2199
    if (op == '+') set_addx_flag();
2200
    else set_subx_flag();
2201
    // write dst (ADEC)
2202
    _ea_write(current_ea2, current_op->reg2_sft);
2203

2204
    terminate_op(6);
2205
}
2206

2207
static void GenArithXM7(char op)
2208
{
2209
    // generate jump table & opcode declaration
2210
    current_ea = EA_ADEC;
2211
    current_ea2 = EA_ADEC7;
2212
    start_all(GEN_ALL);
2213

2214
    if (current_size == SIZE_LONG) current_cycle += 4;
2215

2216
    // read src (ADEC)
2217
    _ea_calc(current_ea, current_op->reg_sft);
2218
    _ea_read_src(current_ea, current_op->reg_sft);
2219
    // read dst (ADEC7)
2220
    _ea_calc(current_ea2, 0);
2221
    _ea_read_dst(current_ea2, 0);
2222
    // op
2223
    wf_op("\tres = dst %c src %c ((CPU->flag_X >> 8) & 1);\n", op, op);
2224
    // flag calculation
2225
    if (op == '+') set_addx_flag();
2226
    else set_subx_flag();
2227
    // write dst (ADEC7)
2228
    _ea_write(current_ea2, 0);
2229

2230
    terminate_op(6);
2231
}
2232

2233
static void GenArithX7M7(char op)
2234
{
2235
    // generate jump table & opcode declaration
2236
    current_ea = EA_ADEC7;
2237
    current_ea2 = EA_ADEC7;
2238
    start_all(GEN_ALL);
2239

2240
    if (current_size == SIZE_LONG) current_cycle += 4;
2241

2242
    // read src (ADEC7)
2243
    _ea_calc(current_ea, 0);
2244
    _ea_read_src(current_ea, 0);
2245
    // read dst (ADEC7)
2246
    _ea_calc(current_ea2, 0);
2247
    _ea_read_dst(current_ea2, 0);
2248
    // op
2249
    wf_op("\tres = dst %c src %c ((CPU->flag_X >> 8) & 1);\n", op, op);
2250
    // flag calculation
2251
    if (op == '+') set_addx_flag();
2252
    else set_subx_flag();
2253
    // write dst (ADEC7)
2254
    _ea_write(current_ea2, 0);
2255

2256
    terminate_op(6);
2257
}
2258

2259
static void GenADDaD()
2260
{
2261
    GenArithaD('+');
2262
}
2263

2264
static void GenADDDa()
2265
{
2266
    GenArithDa('+');
2267
}
2268

2269
static void GenADDA()
2270
{
2271
    GenArithA('+');
2272
}
2273

2274
static void GenADDX()
2275
{
2276
    GenArithX('+');
2277
}
2278

2279
static void GenADDXM()
2280
{
2281
    GenArithXM('+');
2282
}
2283

2284
static void GenADDX7M()
2285
{
2286
    GenArithX7M('+');
2287
}
2288

2289
static void GenADDXM7()
2290
{
2291
    GenArithXM7('+');
2292
}
2293

2294
static void GenADDX7M7()
2295
{
2296
    GenArithX7M7('+');
2297
}
2298

2299
static void GenSUBaD()
2300
{
2301
    GenArithaD('-');
2302
}
2303

2304
static void GenSUBDa()
2305
{
2306
    GenArithDa('-');
2307
}
2308

2309
static void GenSUBA()
2310
{
2311
    GenArithA('-');
2312
}
2313

2314
static void GenSUBX()
2315
{
2316
    GenArithX('-');
2317
}
2318

2319
static void GenSUBXM()
2320
{
2321
    GenArithXM('-');
2322
}
2323

2324
static void GenSUBX7M()
2325
{
2326
    GenArithX7M('-');
2327
}
2328

2329
static void GenSUBXM7()
2330
{
2331
    GenArithXM7('-');
2332
}
2333

2334
static void GenSUBX7M7()
2335
{
2336
    GenArithX7M7('-');
2337
}
2338

2339
static void GenCMP()
2340
{
2341
    GenArithaD(' ');
2342
}
2343

2344
static void GenCMPA()
2345
{
2346
    GenArithA(' ');
2347
}
2348

2349
static void GenCMPM()
2350
{
2351
    // generate jump table & opcode declaration
2352
    current_ea = EA_AINC;
2353
    current_ea2 = EA_AINC;
2354
    start_all(GEN_ALL);
2355

2356
    // read src (ADEC)
2357
    _ea_calc(current_ea, current_op->reg_sft);
2358
    _ea_read_src(current_ea, current_op->reg_sft);
2359
    // read dst (ADEC)
2360
    _ea_calc(current_ea2, current_op->reg2_sft);
2361
    _ea_read_dst(current_ea2, current_op->reg2_sft);
2362
    // op
2363
    wf_op("\tres = dst - src;\n");
2364
    // flag calculation
2365
    set_cmp_flag();
2366

2367
    terminate_op(4);
2368

2369
}
2370

2371
static void GenCMP7M()
2372
{
2373
    // generate jump table & opcode declaration
2374
    current_ea = EA_AINC7;
2375
    current_ea2 = EA_AINC;
2376
    start_all(GEN_ALL);
2377

2378
    // read src (ADEC)
2379
    _ea_calc(current_ea, 0);
2380
    _ea_read_src(current_ea, 0);
2381
    // read dst (ADEC)
2382
    _ea_calc(current_ea2, current_op->reg2_sft);
2383
    _ea_read_dst(current_ea2, current_op->reg2_sft);
2384
    // op
2385
    wf_op("\tres = dst - src;\n");
2386
    // flag calculation
2387
    set_cmp_flag();
2388

2389
    terminate_op(4);
2390

2391
}
2392

2393
static void GenCMPM7()
2394
{
2395
    // generate jump table & opcode declaration
2396
    current_ea = EA_AINC;
2397
    current_ea2 = EA_AINC7;
2398
    start_all(GEN_ALL);
2399

2400
    // read src (ADEC)
2401
    _ea_calc(current_ea, current_op->reg_sft);
2402
    _ea_read_src(current_ea, current_op->reg_sft);
2403
    // read dst (ADEC)
2404
    _ea_calc(current_ea2, 0);
2405
    _ea_read_dst(current_ea2, 0);
2406
    // op
2407
    wf_op("\tres = dst - src;\n");
2408
    // flag calculation
2409
    set_cmp_flag();
2410

2411
    terminate_op(4);
2412

2413
}
2414

2415
static void GenCMP7M7()
2416
{
2417
    // generate jump table & opcode declaration
2418
    current_ea = EA_AINC7;
2419
    current_ea2 = EA_AINC7;
2420
    start_all(GEN_ALL);
2421

2422
    // read src (ADEC)
2423
    _ea_calc(current_ea, 0);
2424
    _ea_read_src(current_ea, 0);
2425
    // read dst (ADEC)
2426
    _ea_calc(current_ea2, 0);
2427
    _ea_read_dst(current_ea2, 0);
2428
    // op
2429
    wf_op("\tres = dst - src;\n");
2430
    // flag calculation
2431
    set_cmp_flag();
2432

2433
    terminate_op(4);
2434

2435
}
2436

2437
static void GenEXGDD()
2438
{
2439
    // generate jump table & opcode declaration
2440
    set_current_size(SIZE_LONG);
2441
    current_ea = EA_DREG;
2442
    current_ea2 = EA_DREG;
2443
    start_all(GEN_RES | GEN_SRC);
2444
    
2445
    // read R1
2446
    _ea_calc(current_ea, current_op->reg_sft);
2447
    _ea_read(current_ea, current_op->reg_sft);
2448
    // read R2
2449
    _ea_calc(current_ea2, current_op->reg2_sft);
2450
    _ea_read_src(current_ea2, current_op->reg2_sft);
2451
    // write R1
2452
    _ea_write(current_ea2, current_op->reg2_sft);
2453
    wf_op("\tres = src;\n");
2454
    // write R2
2455
    _ea_write(current_ea, current_op->reg_sft);
2456

2457
    terminate_op(6);
2458
}
2459

2460
static void GenEXGAA()
2461
{
2462
    // generate jump table & opcode declaration
2463
    set_current_size(SIZE_LONG);
2464
    current_ea = EA_AREG;
2465
    current_ea2 = EA_AREG;
2466
    start_all(GEN_RES | GEN_SRC);
2467

2468
    // read R1
2469
    _ea_calc(current_ea, current_op->reg_sft);
2470
    _ea_read(current_ea, current_op->reg_sft);
2471
    // read R2
2472
    _ea_calc(current_ea2, current_op->reg2_sft);
2473
    _ea_read_src(current_ea2, current_op->reg2_sft);
2474
    // write R1
2475
    _ea_write(current_ea2, current_op->reg2_sft);
2476
    wf_op("\tres = src;\n");
2477
    // write R2
2478
    _ea_write(current_ea, current_op->reg_sft);
2479

2480
    terminate_op(6);
2481
}
2482

2483
static void GenEXGAD()
2484
{
2485
    // generate jump table & opcode declaration
2486
    set_current_size(SIZE_LONG);
2487
    current_ea = EA_AREG;
2488
    current_ea2 = EA_DREG;
2489
    start_all(GEN_RES | GEN_SRC);
2490

2491
    // read R1
2492
    _ea_calc(current_ea, current_op->reg_sft);
2493
    _ea_read(current_ea, current_op->reg_sft);
2494
    // read R2
2495
    _ea_calc(current_ea2, current_op->reg2_sft);
2496
    _ea_read_src(current_ea2, current_op->reg2_sft);
2497
    // write R1
2498
    _ea_write(current_ea2, current_op->reg2_sft);
2499
    wf_op("\tres = src;\n");
2500
    // write R2
2501
    _ea_write(current_ea, current_op->reg_sft);
2502

2503
    terminate_op(6);
2504
}
2505

2506
static void GenASRk()
2507
{
2508
    u32 base;
2509
    
2510
    current_ea = EA_DREG;               // dst = Dx
2511

2512
    base = get_current_opcode_base();
2513
    // generate jump table
2514
    gen_opjumptable_ext(base, 0x0000, 0x0E00, 0x0200, base);
2515
    // generate label & declarations
2516
    start_op(base, GEN_RES | GEN_SRC);
2517

2518
    if (current_size == SIZE_LONG) current_cycle += 2;
2519

2520
    wf_op("\tu32 sft;\n");
2521
    wf_op("\n");
2522
    wf_op("\tsft = (((Opcode >> 9) - 1) & 7) + 1;\n");
2523
    adds_CCnt("sft * 2");
2524

2525
    // read (sign extend)
2526
    _ea_calc(current_ea, current_op->reg_sft);
2527
    _ea_read_src_sx(current_ea, current_op->reg_sft);
2528

2529
    // op & flag calculation
2530
    wf_op("\tCPU->flag_V = 0;\n");
2531
    wf_op("\tCPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft);\n");
2532
    wf_op("\tres = ((s32)src) >> sft;\n");
2533
    wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
2534
    wf_op("\tCPU->flag_notZ = res;\n");
2535
    
2536
    // write
2537
    _ea_write(current_ea, current_op->reg_sft);
2538

2539
    terminate_op(6);
2540
}
2541

2542
static void GenLSRk()
2543
{
2544
    u32 base;
2545

2546
    current_ea = EA_DREG;               // dst = Dx
2547

2548
    base = get_current_opcode_base();
2549
    // generate jump table
2550
    gen_opjumptable_ext(base, 0x0000, 0x0E00, 0x0200, base);
2551
    // generate label & declarations
2552
    start_op(base, GEN_RES | GEN_SRC);
2553

2554
    if (current_size == SIZE_LONG) current_cycle += 2;
2555

2556
    wf_op("\tu32 sft;\n");
2557
    wf_op("\n");
2558
    wf_op("\tsft = (((Opcode >> 9) - 1) & 7) + 1;\n");
2559
    adds_CCnt("sft * 2");
2560

2561
    // read
2562
    _ea_calc(current_ea, current_op->reg_sft);
2563
    _ea_read_src(current_ea, current_op->reg_sft);
2564

2565
    // op & flag calculation
2566
    wf_op("\tCPU->flag_N = CPU->flag_V = 0;\n");
2567
    wf_op("\tCPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft);\n");
2568
    wf_op("\tres = src >> sft;\n");
2569
    wf_op("\tCPU->flag_notZ = res;\n");
2570

2571
    // write
2572
    _ea_write(current_ea, current_op->reg_sft);
2573

2574
    terminate_op(6);
2575
}
2576

2577
static void GenROXRk()
2578
{
2579
    u32 base;
2580

2581
    current_ea = EA_DREG;               // dst = Dx
2582

2583
    base = get_current_opcode_base();
2584
    // generate jump table
2585
    gen_opjumptable_ext(base, 0x0000, 0x0E00, 0x0200, base);
2586
    // generate label & declarations
2587
    start_op(base, GEN_RES | GEN_SRC);
2588

2589
    if (current_size == SIZE_LONG) current_cycle += 2;
2590

2591
    wf_op("\tu32 sft;\n");
2592
    wf_op("\n");
2593
    wf_op("\tsft = (((Opcode >> 9) - 1) & 7) + 1;\n");
2594
    adds_CCnt("sft * 2");
2595

2596
    // read
2597
    _ea_calc(current_ea, current_op->reg_sft);
2598
    _ea_read_src(current_ea, current_op->reg_sft);
2599

2600
    // op & C / X flags calculation
2601
    if (current_size != SIZE_LONG)
2602
    {
2603
        wf_op("\tsrc |= (CPU->flag_X & C68K_SR_X) << %d;\n", (current_sft_mask + 1) - C68K_SR_X_SFT);
2604
        wf_op("\tres = (src >> sft) | (src << (%d - sft));\n", current_sft_mask + 2);
2605
        wf_op("\tCPU->flag_X = CPU->flag_C = res >> %d;\n", (current_sft_mask + 1) - C68K_SR_X_SFT);
2606
    }
2607
    else
2608
    {
2609
        wf_op("\tCPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft);\n");
2610
        wf_op("\tif (sft == 1) res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << (32 - (C68K_SR_X_SFT + 1)));\n");
2611
        wf_op("\telse res = (src >> sft) | (src << (33 - sft)) | ((CPU->flag_X & C68K_SR_X) << (32 - (C68K_SR_X_SFT + sft)));\n");
2612
        wf_op("\tCPU->flag_X = CPU->flag_C;\n");
2613
    }
2614

2615
    // V / N / Z flags calculation
2616
    wf_op("\tCPU->flag_V = 0;\n");
2617
    wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
2618
    if (current_size == SIZE_LONG) wf_op("\tCPU->flag_notZ = res;\n");
2619
    else wf_op("\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask);
2620

2621
    // write
2622
    _ea_write(current_ea, current_op->reg_sft);
2623

2624
    terminate_op(6);
2625
}
2626

2627
static void GenRORk()
2628
{
2629
    u32 base;
2630

2631
    current_ea = EA_DREG;               // dst = Dx
2632

2633
    base = get_current_opcode_base();
2634
    // generate jump table
2635
    gen_opjumptable_ext(base, 0x0000, 0x0E00, 0x0200, base);
2636
    // generate label & declarations
2637
    start_op(base, GEN_RES | GEN_SRC);
2638

2639
    if (current_size == SIZE_LONG) current_cycle += 2;
2640

2641
    wf_op("\tu32 sft;\n");
2642
    wf_op("\n");
2643
    wf_op("\tsft = (((Opcode >> 9) - 1) & 7) + 1;\n");
2644
    adds_CCnt("sft * 2");
2645

2646
    // read
2647
    _ea_calc(current_ea, current_op->reg_sft);
2648
    _ea_read_src(current_ea, current_op->reg_sft);
2649

2650
    // op & flag calculation
2651
    wf_op("\tCPU->flag_V = 0;\n");
2652
    wf_op("\tCPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft);\n");
2653
    wf_op("\tres = (src >> sft) | (src << (%d - sft));\n", current_sft_mask + 1);
2654
    wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
2655
    if (current_size == SIZE_LONG) wf_op("\tCPU->flag_notZ = res;\n");
2656
    else wf_op("\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask);
2657

2658
    // write
2659
    _ea_write(current_ea, current_op->reg_sft);
2660

2661
    terminate_op(6);
2662
}
2663

2664
static void GenASLk()
2665
{
2666
    u32 base;
2667

2668
    current_ea = EA_DREG;               // dst = Dx
2669
    
2670
    base = get_current_opcode_base();
2671
    // generate jump table
2672
    gen_opjumptable_ext(base, 0x0000, 0x0E00, 0x0200, base);
2673
    // generate label & declarations
2674
    start_op(base, GEN_RES | GEN_SRC);
2675
    
2676
    if (current_size == SIZE_LONG) current_cycle += 2;
2677

2678
    wf_op("\tu32 sft;\n");
2679
    wf_op("\n");
2680
    wf_op("\tsft = (((Opcode >> 9) - 1) & 7) + 1;\n");
2681
    adds_CCnt("sft * 2");
2682

2683
    // read
2684
    _ea_calc(current_ea, current_op->reg_sft);
2685
    _ea_read_src(current_ea, current_op->reg_sft);
2686

2687
    // if (shift < size op) ... only for BYTE here
2688
    if (current_size == SIZE_BYTE)
2689
    {
2690
        wf_op("\tif (sft < %d)\n", current_sft_mask + 1);
2691
        wf_op("\t{\n");
2692
    }
2693

2694
        // op & flag X, C, N, Z calculation
2695
        if (((current_sft_mask + 1) - C68K_SR_C_SFT) < 8)
2696
            wf_op("\t\tCPU->flag_X = CPU->flag_C = src << (%d + sft);\n", current_sft_mask + 1 - C68K_SR_C_SFT);
2697
        else wf_op("\t\tCPU->flag_X = CPU->flag_C = src >> (%d - sft);\n", current_sft_mask + 1 - C68K_SR_C_SFT);
2698
        wf_op("\t\tres = src << sft;\n");
2699
        wf_op("\t\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
2700
        wf_op("\t\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask);
2701

2702
        // write
2703
        _ea_write(current_ea, current_op->reg_sft);
2704

2705
        // we do V flag calculation at end for a better register usage
2706
        wf_op("\t\tCPU->flag_V = 0;\n");
2707
        if (current_size == SIZE_BYTE)
2708
        {
2709
            wf_op("\t\tif ((sft > %d) && (src)) CPU->flag_V = C68K_SR_V;\n", current_sft_mask);
2710
            wf_op("\t\telse\n");
2711
            }
2712
        wf_op("\t\t{\n");
2713
            wf_op("\t\t\tu32 msk = (((s32)0x80000000) >> (sft + %d)) & 0x%.8X;\n", 31 - current_sft_mask, current_bits_mask);
2714
            wf_op("\t\t\tsrc &= msk;\n");
2715
            wf_op("\t\t\tif ((src) && (src != msk)) CPU->flag_V = C68K_SR_V;\n");
2716
        wf_op("\t\t}\n");
2717
        
2718
    if (current_size == SIZE_BYTE)
2719
    {
2720
        quick_terminate_op(6);
2721
        wf_op("\t}\n");
2722
        wf_op("\n");
2723
    
2724
        // special case of shift == size op (sft = 8 for byte operation)
2725
        wf_op("\tif (src) CPU->flag_V = C68K_SR_V;\n");
2726
        wf_op("\telse CPU->flag_V = 0;\n");
2727
        wf_op("\tCPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT;\n");
2728

2729
        // write
2730
        wf_op("\tres = 0;\n");
2731
        _ea_write(current_ea, current_op->reg_sft);
2732

2733
        // others flags
2734
        wf_op("\tCPU->flag_N = 0;\n");
2735
        wf_op("\tCPU->flag_notZ = 0;\n");
2736
    }
2737
    
2738
    terminate_op(6);
2739
}
2740

2741
static void GenLSLk()
2742
{
2743
    u32 base;
2744

2745
    current_ea = EA_DREG;               // dst = Dx
2746

2747
    base = get_current_opcode_base();
2748
    // generate jump table
2749
    gen_opjumptable_ext(base, 0x0000, 0x0E00, 0x0200, base);
2750
    // generate label & declarations
2751
    start_op(base, GEN_RES | GEN_SRC);
2752

2753
    if (current_size == SIZE_LONG) current_cycle += 2;
2754

2755
    wf_op("\tu32 sft;\n");
2756
    wf_op("\n");
2757
    wf_op("\tsft = (((Opcode >> 9) - 1) & 7) + 1;\n");
2758
    adds_CCnt("sft * 2");
2759

2760
    // read
2761
    _ea_calc(current_ea, current_op->reg_sft);
2762
    _ea_read_src(current_ea, current_op->reg_sft);
2763

2764
    // op & flag calculation
2765
    wf_op("\tCPU->flag_V = 0;\n");
2766
    if (((current_sft_mask + 1) - C68K_SR_C_SFT) < 8)
2767
        wf_op("\tCPU->flag_X = CPU->flag_C = src << (%d + sft);\n", current_sft_mask + 1 - C68K_SR_C_SFT);
2768
    else wf_op("\tCPU->flag_X = CPU->flag_C = src >> (%d - sft);\n", current_sft_mask + 1 - C68K_SR_C_SFT);
2769
    wf_op("\tres = src << sft;\n");
2770
    wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
2771
    wf_op("\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask);
2772

2773
    // write
2774
    _ea_write(current_ea, current_op->reg_sft);
2775

2776
    terminate_op(6);
2777
}
2778

2779
static void GenROXLk()
2780
{
2781
    u32 base;
2782

2783
    current_ea = EA_DREG;               // dst = Dx
2784

2785
    base = get_current_opcode_base();
2786
    // generate jump table
2787
    gen_opjumptable_ext(base, 0x0000, 0x0E00, 0x0200, base);
2788
    // generate label & declarations
2789
    start_op(base, GEN_RES | GEN_SRC);
2790

2791
    if (current_size == SIZE_LONG) current_cycle += 2;
2792

2793
    wf_op("\tu32 sft;\n");
2794
    wf_op("\n");
2795
    wf_op("\tsft = (((Opcode >> 9) - 1) & 7) + 1;\n");
2796
    adds_CCnt("sft * 2");
2797

2798
    // read
2799
    _ea_calc(current_ea, current_op->reg_sft);
2800
    _ea_read_src(current_ea, current_op->reg_sft);
2801

2802
    // op & C / X flags calculation
2803
    if (current_size != SIZE_LONG)
2804
    {
2805
        wf_op("\tsrc |= (CPU->flag_X & C68K_SR_X) << %d;\n", (current_sft_mask + 1) - C68K_SR_X_SFT);
2806
        wf_op("\tres = (src << sft) | (src >> (%d - sft));\n", current_sft_mask + 2);
2807
        wf_op("\tCPU->flag_X = CPU->flag_C = res >> %d;\n", (current_sft_mask + 1) - C68K_SR_X_SFT);
2808
    }
2809
    else
2810
    {
2811
        wf_op("\tCPU->flag_C = src >> ((32 - C68K_SR_C_SFT) - sft);\n");
2812
        wf_op("\tif (sft == 1) res = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> ((C68K_SR_X_SFT + 1) - 1));\n");
2813
        wf_op("\telse res = (src << sft) | (src >> (33 - sft)) | ((CPU->flag_X & C68K_SR_X) >> ((C68K_SR_X_SFT + 1) - sft));\n");
2814
        wf_op("\tCPU->flag_X = CPU->flag_C;\n");
2815
    }
2816

2817
    // V / N / Z flags calculation
2818
    wf_op("\tCPU->flag_V = 0;\n");
2819
    wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
2820
    if (current_size == SIZE_LONG) wf_op("\tCPU->flag_notZ = res;\n");
2821
    else wf_op("\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask);
2822

2823
    // write
2824
    _ea_write(current_ea, current_op->reg_sft);
2825

2826
    terminate_op(6);
2827
}
2828

2829
static void GenROLk()
2830
{
2831
    u32 base;
2832

2833
    current_ea = EA_DREG;               // dst = Dx
2834

2835
    base = get_current_opcode_base();
2836
    // generate jump table
2837
    gen_opjumptable_ext(base, 0x0000, 0x0E00, 0x0200, base);
2838
    // generate label & declarations
2839
    start_op(base, GEN_RES | GEN_SRC);
2840

2841
    if (current_size == SIZE_LONG) current_cycle += 2;
2842

2843
    wf_op("\tu32 sft;\n");
2844
    wf_op("\n");
2845
    wf_op("\tsft = (((Opcode >> 9) - 1) & 7) + 1;\n");
2846
    adds_CCnt("sft * 2");
2847

2848
    // read
2849
    _ea_calc(current_ea, current_op->reg_sft);
2850
    _ea_read_src(current_ea, current_op->reg_sft);
2851

2852
    // op & flag calculation
2853
    wf_op("\tCPU->flag_V = 0;\n");
2854
    if (((current_sft_mask + 1) - C68K_SR_C_SFT) < 8)
2855
        wf_op("\tCPU->flag_C = src << (%d + sft);\n", current_sft_mask + 1 - C68K_SR_C_SFT);
2856
    else wf_op("\tCPU->flag_C = src >> (%d - sft);\n", current_sft_mask + 1 - C68K_SR_C_SFT);
2857
    wf_op("\tres = (src << sft) | (src >> (%d - sft));\n", current_sft_mask + 1);
2858
    wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
2859
    if (current_size == SIZE_LONG) wf_op("\tCPU->flag_notZ = res;\n");
2860
    else wf_op("\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask);
2861

2862
    // write
2863
    _ea_write(current_ea, current_op->reg_sft);
2864

2865
    terminate_op(6);
2866
}
2867

2868
static void GenASRD()
2869
{
2870
//    u32 base = get_current_opcode_base();
2871

2872
    current_ea = EA_DREG;               // dst = Dx
2873

2874
    start_all(GEN_RES | GEN_SRC);
2875

2876
    if (current_size == SIZE_LONG) current_cycle += 2;
2877

2878
    wf_op("\tu32 sft;\n");
2879
    wf_op("\n");
2880
    wf_op("\tsft = CPU->D[(Opcode >> %d) & 7] & 0x3F;\n", current_op->reg2_sft);
2881

2882
    // read (sign extend)
2883
    _ea_calc(current_ea, current_op->reg_sft);
2884
    _ea_read_src_sx(current_ea, current_op->reg_sft);
2885

2886
    // if (shift != 0)
2887
    wf_op("\tif (sft)\n");
2888
    wf_op("\t{\n");
2889
    
2890
        adds_CCnt("sft * 2");
2891
        
2892
        // if (shift < size op)
2893
        wf_op("\t\tif (sft < %d)\n", current_sft_mask + 1);
2894
        wf_op("\t\t{\n");
2895

2896
            // op & flag calculation
2897
            wf_op("\t\t\tCPU->flag_V = 0;\n");
2898
            if (current_size == SIZE_BYTE) wf_op("\t\t\tCPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft);\n");
2899
            else wf_op("\t\t\tCPU->flag_X = CPU->flag_C = (src >> (sft - 1)) << C68K_SR_C_SFT;\n");
2900
            wf_op("\t\t\tres = ((s32)src) >> sft;\n", szcs);
2901
            wf_op("\t\t\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
2902
            wf_op("\t\t\tCPU->flag_notZ = res;\n");
2903
            
2904
            // write
2905
            _ea_write(current_ea, current_op->reg_sft);
2906

2907
            quick_terminate_op(6);
2908
        wf_op("\t\t}\n");
2909
        wf_op("\n");
2910

2911
        // special case of shift >= size op
2912
        
2913
        // if signed
2914
        wf_op("\t\tif (src & (1 << %d))\n", current_sft_mask);
2915
        wf_op("\t\t{\n");
2916
        
2917
            // op & flag calculation
2918
            wf_op("\t\t\tCPU->flag_N = C68K_SR_N;\n");
2919
            wf_op("\t\t\tCPU->flag_notZ = 1;\n");
2920
            wf_op("\t\t\tCPU->flag_V = 0;\n");
2921
            wf_op("\t\t\tCPU->flag_C = C68K_SR_C;\n");
2922
            wf_op("\t\t\tCPU->flag_X = C68K_SR_X;\n");
2923
            wf_op("\t\t\tres = 0x%.8X;\n", current_bits_mask);
2924

2925
            // write
2926
            _ea_write(current_ea, current_op->reg_sft);
2927
            
2928
            quick_terminate_op(6);
2929
        wf_op("\t\t}\n");
2930
        wf_op("\n");
2931

2932
        // if not signed
2933
        wf_op("\t\tCPU->flag_N = 0;\n");
2934
        wf_op("\t\tCPU->flag_notZ = 0;\n");
2935
        wf_op("\t\tCPU->flag_V = 0;\n");
2936
        wf_op("\t\tCPU->flag_C = 0;\n");
2937
        wf_op("\t\tCPU->flag_X = 0;\n");
2938
        wf_op("\t\tres = 0;\n");
2939

2940
        // write
2941
        _ea_write(current_ea, current_op->reg_sft);
2942

2943
        quick_terminate_op(6);
2944
    wf_op("\t}\n");
2945
    wf_op("\n");
2946

2947
    // special case of (shift == 0)
2948
    wf_op("\tCPU->flag_V = 0;\n");
2949
    wf_op("\tCPU->flag_C = 0;\n");
2950
    wf_op("\tCPU->flag_N = src >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
2951
    wf_op("\tCPU->flag_notZ = src;\n");
2952

2953
    terminate_op(6);
2954
}
2955

2956
static void GenLSRD()
2957
{
2958
//    u32 base = get_current_opcode_base();
2959

2960
    current_ea = EA_DREG;               // dst = Dx
2961

2962
    start_all(GEN_RES | GEN_SRC);
2963

2964
    if (current_size == SIZE_LONG) current_cycle += 2;
2965

2966
    wf_op("\tu32 sft;\n");
2967
    wf_op("\n");
2968
    wf_op("\tsft = CPU->D[(Opcode >> %d) & 7] & 0x3F;\n", current_op->reg2_sft);
2969

2970
    // read
2971
    _ea_calc(current_ea, current_op->reg_sft);
2972
    _ea_read_src(current_ea, current_op->reg_sft);
2973

2974
    // if (shift != 0)
2975
    wf_op("\tif (sft)\n");
2976
    wf_op("\t{\n");
2977

2978
        adds_CCnt("sft * 2");
2979

2980
        // if (shift <= size op)
2981
        if (current_size == SIZE_LONG) wf_op("\t\tif (sft < 32)\n");
2982
        else wf_op("\t\tif (sft <= %d)\n", current_sft_mask + 1);
2983
        wf_op("\t\t{\n");
2984

2985
            // op & flag calculation
2986
            wf_op("\t\t\tCPU->flag_N = CPU->flag_V = 0;\n");
2987
            if (current_size == SIZE_BYTE) wf_op("\t\t\tCPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft);\n");
2988
            else wf_op("\t\t\tCPU->flag_X = CPU->flag_C = (src >> (sft - 1)) << C68K_SR_C_SFT;\n");
2989
            wf_op("\t\t\tres = src >> sft;\n", szcs);
2990
            wf_op("\t\t\tCPU->flag_notZ = res;\n");
2991

2992
            // write
2993
            _ea_write(current_ea, current_op->reg_sft);
2994

2995
            quick_terminate_op(6);
2996
        wf_op("\t\t}\n");
2997
        wf_op("\n");
2998

2999
        // special case of shift > size op
3000
        if (current_size == SIZE_LONG)
3001
        {
3002
            wf_op("\t\tif (sft == 32) CPU->flag_C = src >> (31 - C68K_SR_C_SFT);\n");
3003
            wf_op("\t\telse CPU->flag_C = 0;\n");
3004
            wf_op("\t\tCPU->flag_X = CPU->flag_C;\n");
3005
        }
3006
        else wf_op("\t\tCPU->flag_X = CPU->flag_C = 0;\n");
3007
        wf_op("\t\tCPU->flag_N = 0;\n");
3008
        wf_op("\t\tCPU->flag_notZ = 0;\n");
3009
        wf_op("\t\tCPU->flag_V = 0;\n");
3010
        wf_op("\t\tres = 0;\n");
3011

3012
        // write
3013
        _ea_write(current_ea, current_op->reg_sft);
3014

3015
        quick_terminate_op(6);
3016
    wf_op("\t}\n");
3017
    wf_op("\n");
3018

3019
    // special case of (shift == 0)
3020
    wf_op("\tCPU->flag_V = 0;\n");
3021
    wf_op("\tCPU->flag_C = 0;\n");
3022
    wf_op("\tCPU->flag_N = src >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3023
    wf_op("\tCPU->flag_notZ = src;\n");
3024

3025
    terminate_op(6);
3026
}
3027

3028
static void GenROXRD()
3029
{
3030
//    u32 base = get_current_opcode_base();
3031

3032
    current_ea = EA_DREG;               // dst = Dx
3033

3034
    start_all(GEN_RES | GEN_SRC);
3035

3036
    if (current_size == SIZE_LONG) current_cycle += 2;
3037

3038
    wf_op("\tu32 sft;\n");
3039
    wf_op("\n");
3040
    wf_op("\tsft = CPU->D[(Opcode >> %d) & 7] & 0x3F;\n", current_op->reg2_sft);
3041

3042
    // read
3043
    _ea_calc(current_ea, current_op->reg_sft);
3044
    _ea_read_src(current_ea, current_op->reg_sft);
3045

3046
    // if (shift != 0)
3047
    wf_op("\tif (sft)\n");
3048
    wf_op("\t{\n");
3049

3050
        adds_CCnt("sft * 2");
3051

3052
        wf_op("\t\tsft %%= %d;\n", current_sft_mask + 2);
3053
        wf_op("\n");
3054

3055
        // op & C / X flag calculation
3056
        if (current_size != SIZE_LONG)
3057
        {
3058
            wf_op("\t\tsrc |= (CPU->flag_X & C68K_SR_X) << %d;\n", (current_sft_mask + 1) - C68K_SR_X_SFT);
3059
            wf_op("\t\tres = (src >> sft) | (src << (%d - sft));\n", current_sft_mask + 2);
3060
            wf_op("\t\tCPU->flag_X = CPU->flag_C = res >> %d;\n", (current_sft_mask + 1) - C68K_SR_X_SFT);
3061
        }
3062
        else
3063
        {
3064
            wf_op("\t\tif (sft != 0)\n");
3065
            wf_op("\t\t{\n");
3066
            wf_op("\t\t\tif (sft == 1) res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << (32 - (C68K_SR_X_SFT + 1)));\n");
3067
            wf_op("\t\t\telse res = (src >> sft) | (src << (33 - sft)) | (((CPU->flag_X & C68K_SR_X) << (32 - (C68K_SR_X_SFT + 1))) >> (sft - 1));\n");
3068
            wf_op("\t\t\tCPU->flag_X = (src >> (32 - sft)) << C68K_SR_X_SFT;\n");
3069
            wf_op("\t\t}\n");
3070
            wf_op("\t\telse res = src;\n");
3071
            wf_op("\t\tCPU->flag_C = CPU->flag_X;\n");
3072
        }
3073

3074
        // V / N / Z flag calculation
3075
        wf_op("\t\tCPU->flag_V = 0;\n");
3076
        wf_op("\t\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3077
        if (current_size == SIZE_LONG) wf_op("\t\tCPU->flag_notZ = res;\n");
3078
        else wf_op("\t\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask);
3079

3080
        // write
3081
        _ea_write(current_ea, current_op->reg_sft);
3082

3083
        quick_terminate_op(6);
3084
    wf_op("\t}\n");
3085
    wf_op("\n");
3086

3087
    // special case of (shift == 0)
3088
    wf_op("\tCPU->flag_V = 0;\n");
3089
    wf_op("\tCPU->flag_C = CPU->flag_X;\n");
3090
    wf_op("\tCPU->flag_N = src >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3091
    wf_op("\tCPU->flag_notZ = src;\n");
3092

3093
    terminate_op(6);
3094
}
3095

3096
static void GenRORD()
3097
{
3098
//    u32 base = get_current_opcode_base();
3099

3100
    current_ea = EA_DREG;               // dst = Dx
3101

3102
    start_all(GEN_RES | GEN_SRC);
3103

3104
    if (current_size == SIZE_LONG) current_cycle += 2;
3105

3106
    wf_op("\tu32 sft;\n");
3107
    wf_op("\n");
3108
    wf_op("\tsft = CPU->D[(Opcode >> %d) & 7] & 0x3F;\n", current_op->reg2_sft);
3109

3110
    // read
3111
    _ea_calc(current_ea, current_op->reg_sft);
3112
    _ea_read_src(current_ea, current_op->reg_sft);
3113

3114
    // if (shift != 0)
3115
    wf_op("\tif (sft)\n");
3116
    wf_op("\t{\n");
3117

3118
        adds_CCnt("sft * 2");
3119

3120
        wf_op("\t\tsft &= 0x%.2X;\n", current_sft_mask);
3121
        wf_op("\t\t\n");
3122

3123
        // op & flag calculation
3124
        if (current_size == SIZE_BYTE)
3125
            wf_op("\t\tCPU->flag_C = src << (C68K_SR_C_SFT - ((sft - 1) & 7));\n");
3126
        else
3127
            wf_op("\t\tCPU->flag_C = (src >> ((sft - 1) & %d)) << C68K_SR_C_SFT;\n", current_sft_mask);
3128
        wf_op("\t\tres = (src >> sft) | (src << (%d - sft));\n", current_sft_mask + 1);
3129
        wf_op("\t\tCPU->flag_V = 0;\n");
3130
        wf_op("\t\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3131
        if (current_size == SIZE_LONG) wf_op("\t\tCPU->flag_notZ = res;\n");
3132
        else wf_op("\t\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask);
3133

3134
        // write
3135
        _ea_write(current_ea, current_op->reg_sft);
3136

3137
        quick_terminate_op(6);
3138
    wf_op("\t}\n");
3139
    wf_op("\n");
3140

3141
    // special case of (shift == 0)
3142
    wf_op("\tCPU->flag_V = 0;\n");
3143
    wf_op("\tCPU->flag_C = 0;\n");
3144
    wf_op("\tCPU->flag_N = src >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3145
    wf_op("\tCPU->flag_notZ = src;\n");
3146

3147
    terminate_op(6);
3148
}
3149

3150
static void GenASLD()
3151
{
3152
//    u32 base = get_current_opcode_base();
3153

3154
    current_ea = EA_DREG;               // dst = Dx
3155

3156
    start_all(GEN_RES | GEN_SRC);
3157

3158
    if (current_size == SIZE_LONG) current_cycle += 2;
3159

3160
    wf_op("\tu32 sft;\n");
3161
    wf_op("\n");
3162
    wf_op("\tsft = CPU->D[(Opcode >> %d) & 7] & 0x3F;\n", current_op->reg2_sft);
3163

3164
    // read
3165
    _ea_calc(current_ea, current_op->reg_sft);
3166
    _ea_read_src(current_ea, current_op->reg_sft);
3167

3168
    // if (shift != 0)
3169
    wf_op("\tif (sft)\n");
3170
    wf_op("\t{\n");
3171

3172
        adds_CCnt("sft * 2");
3173

3174
        // if (shift < size op)
3175
        wf_op("\t\tif (sft < %d)\n", current_sft_mask + 1);
3176
        wf_op("\t\t{\n");
3177

3178
            // op & flag calculation
3179
            if (current_size != SIZE_LONG)
3180
            {
3181
                wf_op("\t\t\tCPU->flag_X = CPU->flag_C = (src << sft) >> %d;\n", (current_sft_mask + 1) - C68K_SR_C_SFT);
3182
                wf_op("\t\t\tres = (src << sft) & 0x%.8X;\n", current_bits_mask);
3183
            }
3184
            else
3185
            {
3186
                wf_op("\t\t\tCPU->flag_X = CPU->flag_C = (src >> (32 - sft)) << C68K_SR_C_SFT;\n");
3187
                wf_op("\t\t\tres = src << sft;\n");
3188
            }
3189
            wf_op("\t\t\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3190
            wf_op("\t\t\tCPU->flag_notZ = res;\n", current_bits_mask);
3191

3192
            // write
3193
            _ea_write(current_ea, current_op->reg_sft);
3194
            
3195
            // we do V flag calculation at end for a better register usage
3196
            wf_op("\t\t\tCPU->flag_V = 0;\n");
3197
            wf_op("\t\t\t{\n");
3198
                wf_op("\t\t\t\tu32 msk = (((s32)0x80000000) >> (sft + %d)) & 0x%.8X;\n", 31 - current_sft_mask, current_bits_mask);
3199
                wf_op("\t\t\t\tsrc &= msk;\n");
3200
                wf_op("\t\t\t\tif ((src) && (src != msk)) CPU->flag_V = C68K_SR_V;\n");
3201
            wf_op("\t\t\t}\n");
3202

3203
            quick_terminate_op(6);
3204
        wf_op("\t\t}\n");
3205
        wf_op("\n");
3206

3207
        // special case of shift >= size op
3208
        wf_op("\t\tif (sft == %d) CPU->flag_C = src << C68K_SR_C_SFT;\n", current_bits_mask + 1);
3209
        wf_op("\t\telse CPU->flag_C = 0;\n");
3210
        wf_op("\t\tCPU->flag_X = CPU->flag_C;\n");
3211
        wf_op("\t\tif (src) CPU->flag_V = C68K_SR_V;\n");
3212
        wf_op("\t\telse CPU->flag_V = 0;\n");
3213
        
3214
        wf_op("\t\tres = 0;\n");
3215
        // write
3216
        _ea_write(current_ea, current_op->reg_sft);
3217
        
3218
        // others flags
3219
        wf_op("\t\tCPU->flag_N = 0;\n");
3220
        wf_op("\t\tCPU->flag_notZ = 0;\n");
3221

3222
        quick_terminate_op(6);
3223
    wf_op("\t}\n");
3224
    wf_op("\n");
3225

3226
    // special case of (shift == 0)
3227
    wf_op("\tCPU->flag_V = 0;\n");
3228
    wf_op("\tCPU->flag_C = 0;\n");
3229
    wf_op("\tCPU->flag_N = src >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3230
    wf_op("\tCPU->flag_notZ = src;\n");
3231

3232
    terminate_op(6);
3233
}
3234

3235
static void GenLSLD()
3236
{
3237
//    u32 base = get_current_opcode_base();
3238

3239
    current_ea = EA_DREG;               // dst = Dx
3240

3241
    start_all(GEN_RES | GEN_SRC);
3242

3243
    if (current_size == SIZE_LONG) current_cycle += 2;
3244

3245
    wf_op("\tu32 sft;\n");
3246
    wf_op("\n");
3247
    wf_op("\tsft = CPU->D[(Opcode >> %d) & 7] & 0x3F;\n", current_op->reg2_sft);
3248

3249
    // read
3250
    _ea_calc(current_ea, current_op->reg_sft);
3251
    _ea_read_src(current_ea, current_op->reg_sft);
3252

3253
    // if (shift != 0)
3254
    wf_op("\tif (sft)\n");
3255
    wf_op("\t{\n");
3256

3257
        adds_CCnt("sft * 2");
3258

3259
        // if (shift <= size op)
3260
        if (current_size == SIZE_LONG) wf_op("\t\tif (sft < 32)\n");
3261
        else wf_op("\t\tif (sft <= %d)\n", current_sft_mask + 1);
3262
        wf_op("\t\t{\n");
3263

3264
            // op & flag calculation
3265
            if (current_size != SIZE_LONG)
3266
            {
3267
                wf_op("\t\t\tCPU->flag_X = CPU->flag_C = (src << sft) >> %d;\n", (current_sft_mask + 1) - C68K_SR_C_SFT);
3268
                wf_op("\t\t\tres = (src << sft) & 0x%.8X;\n", current_bits_mask);
3269
            }
3270
            else
3271
            {
3272
                wf_op("\t\t\tCPU->flag_X = CPU->flag_C = (src >> (32 - sft)) << C68K_SR_C_SFT;\n");
3273
                wf_op("\t\t\tres = src << sft;\n");
3274
            }
3275
            wf_op("\t\t\tCPU->flag_V = 0;\n");
3276
            wf_op("\t\t\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3277
            wf_op("\t\t\tCPU->flag_notZ = res;\n", current_bits_mask);
3278

3279
            // write
3280
            _ea_write(current_ea, current_op->reg_sft);
3281

3282
            quick_terminate_op(6);
3283
        wf_op("\t\t}\n");
3284
        wf_op("\n");
3285

3286
        // special case of shift > size op
3287
        if (current_size == SIZE_LONG)
3288
        {
3289
            wf_op("\t\tif (sft == 32) CPU->flag_C = src << C68K_SR_C_SFT;\n");
3290
            wf_op("\t\telse CPU->flag_C = 0;\n");
3291
            wf_op("\t\tCPU->flag_X = CPU->flag_C;\n");
3292
        }
3293
        else wf_op("\t\tCPU->flag_X = CPU->flag_C = 0;\n");
3294
        wf_op("\t\tCPU->flag_N = 0;\n");
3295
        wf_op("\t\tCPU->flag_notZ = 0;\n");
3296
        wf_op("\t\tCPU->flag_V = 0;\n");
3297
        wf_op("\t\tres = 0;\n");
3298

3299
        // write
3300
        _ea_write(current_ea, current_op->reg_sft);
3301

3302
        quick_terminate_op(6);
3303
    wf_op("\t}\n");
3304
    wf_op("\n");
3305

3306
    // special case of (shift == 0)
3307
    wf_op("\tCPU->flag_V = 0;\n");
3308
    wf_op("\tCPU->flag_C = 0;\n");
3309
    wf_op("\tCPU->flag_N = src >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3310
    wf_op("\tCPU->flag_notZ = src;\n");
3311

3312
    terminate_op(6);
3313
}
3314

3315
static void GenROXLD()
3316
{
3317
//    u32 base = get_current_opcode_base();
3318

3319
    current_ea = EA_DREG;               // dst = Dx
3320

3321
    start_all(GEN_RES | GEN_SRC);
3322

3323
    if (current_size == SIZE_LONG) current_cycle += 2;
3324

3325
    wf_op("\tu32 sft;\n");
3326
    wf_op("\n");
3327
    wf_op("\tsft = CPU->D[(Opcode >> %d) & 7] & 0x3F;\n", current_op->reg2_sft);
3328

3329
    // read
3330
    _ea_calc(current_ea, current_op->reg_sft);
3331
    _ea_read_src(current_ea, current_op->reg_sft);
3332

3333
    // if (shift != 0)
3334
    wf_op("\tif (sft)\n");
3335
    wf_op("\t{\n");
3336

3337
        adds_CCnt("sft * 2");
3338

3339
        wf_op("\t\tsft %%= %d;\n", current_sft_mask + 2);
3340
        wf_op("\n");
3341
        
3342
        // op & C/X flags calculation
3343
        if (current_size != SIZE_LONG)
3344
        {
3345
            wf_op("\t\tsrc |= (CPU->flag_X & C68K_SR_X) << %d;\n", (current_sft_mask + 1) - C68K_SR_X_SFT);
3346
            wf_op("\t\tres = (src << sft) | (src >> (%d - sft));\n", current_sft_mask + 2);
3347
            wf_op("\t\tCPU->flag_X = CPU->flag_C = res >> %d;\n", (current_sft_mask + 1) - C68K_SR_X_SFT);
3348
        }
3349
        else
3350
        {
3351
            wf_op("\t\tif (sft != 0)\n");
3352
            wf_op("\t\t{\n");
3353
            wf_op("\t\t\tif (sft == 1) res = (src << 1) | ((CPU->flag_X >> ((C68K_SR_X_SFT + 1) - 1)) & 1);\n");
3354
            wf_op("\t\t\telse res = (src << sft) | (src >> (33 - sft)) | (((CPU->flag_X >> ((C68K_SR_X_SFT + 1) - 1)) & 1) << (sft - 1));\n");
3355
            wf_op("\t\t\tCPU->flag_X = (src >> (32 - sft)) << C68K_SR_X_SFT;\n");
3356
            wf_op("\t\t}\n");
3357
            wf_op("\t\telse res = src;\n");
3358
            wf_op("\t\tCPU->flag_C = CPU->flag_X;\n");
3359
        }
3360

3361
        // V / N / Z flags calculation
3362
        wf_op("\t\tCPU->flag_V = 0;\n");
3363
        wf_op("\t\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3364
        if (current_size == SIZE_LONG) wf_op("\t\tCPU->flag_notZ = res;\n");
3365
        else wf_op("\t\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask);
3366

3367
        // write
3368
        _ea_write(current_ea, current_op->reg_sft);
3369

3370
        quick_terminate_op(6);
3371
    wf_op("\t}\n");
3372
    wf_op("\n");
3373

3374
    // special case of (shift == 0)
3375
    wf_op("\tCPU->flag_V = 0;\n");
3376
    wf_op("\tCPU->flag_C = CPU->flag_X;\n");
3377
    wf_op("\tCPU->flag_N = src >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3378
    wf_op("\tCPU->flag_notZ = src;\n");
3379

3380
    terminate_op(6);
3381
}
3382

3383
static void GenROLD()
3384
{
3385
//    u32 base = get_current_opcode_base();
3386

3387
    current_ea = EA_DREG;               // dst = Dx
3388

3389
    start_all(GEN_RES | GEN_SRC);
3390

3391
    if (current_size == SIZE_LONG) current_cycle += 2;
3392

3393
    wf_op("\tu32 sft;\n");
3394
    wf_op("\n");
3395
    wf_op("\tsft = CPU->D[(Opcode >> %d) & 7] & 0x3F;\n", current_op->reg2_sft);
3396

3397
    // read
3398
    _ea_calc(current_ea, current_op->reg_sft);
3399
    _ea_read_src(current_ea, current_op->reg_sft);
3400

3401
    // if (shift != 0)
3402
    wf_op("\tif (sft)\n");
3403
    wf_op("\t{\n");
3404

3405
        adds_CCnt("sft * 2");
3406

3407
        // if ((shift & size op) != 0)
3408
        wf_op("\t\tif (sft &= 0x%.2X)\n", current_sft_mask);
3409
        wf_op("\t\t{\n");
3410

3411
            // op & flag calculation
3412
            if (current_size != SIZE_LONG)
3413
            {
3414
                wf_op("\t\t\tCPU->flag_C = (src << sft) >> %d;\n", (current_sft_mask + 1) - C68K_SR_C_SFT);
3415
                wf_op("\t\t\tres = ((src << sft) | (src >> (%d - sft))) & 0x%.8X;\n", current_sft_mask + 1, current_bits_mask);
3416
            }
3417
            else
3418
            {
3419
                wf_op("\t\t\tCPU->flag_C = (src >> (32 - sft)) << C68K_SR_C_SFT;\n");
3420
                wf_op("\t\t\tres = (src << sft) | (src >> (%d - sft));\n", current_sft_mask + 1);
3421
            }
3422
            wf_op("\t\t\tCPU->flag_V = 0;\n");
3423
            wf_op("\t\t\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3424
            wf_op("\t\t\tCPU->flag_notZ = res;\n");
3425

3426
            // write
3427
            _ea_write(current_ea, current_op->reg_sft);
3428

3429
            quick_terminate_op(6);
3430
        wf_op("\t\t}\n");
3431
        wf_op("\n");
3432

3433
        // special case of ((shift & size op) == 0)
3434
        wf_op("\t\tCPU->flag_V = 0;\n");
3435
        wf_op("\t\tCPU->flag_C = src << C68K_SR_C_SFT;\n");
3436
        wf_op("\t\tCPU->flag_N = src >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3437
        wf_op("\t\tCPU->flag_notZ = src;\n");
3438

3439
        quick_terminate_op(6);
3440
    wf_op("\t}\n");
3441
    wf_op("\n");
3442

3443
    // special case of (shift == 0)
3444
    wf_op("\tCPU->flag_V = 0;\n");
3445
    wf_op("\tCPU->flag_C = 0;\n");
3446
    wf_op("\tCPU->flag_N = src >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3447
    wf_op("\tCPU->flag_notZ = src;\n");
3448

3449
    terminate_op(6);
3450
}
3451

3452
static void GenASR()
3453
{
3454
    set_current_size(SIZE_WORD);        // dst = mem (word operation)
3455
    start_all(GEN_ADR | GEN_RES | GEN_SRC);
3456

3457
    // read
3458
    _ea_calc(current_ea, current_op->reg_sft);
3459
    _ea_read_src(current_ea, current_op->reg_sft);
3460

3461
    // op & flag calculation
3462
    wf_op("\tCPU->flag_V = 0;\n");
3463
    wf_op("\tCPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT;\n");
3464
    wf_op("\tres = (src >> 1) | (src & (1 << %d));\n", current_sft_mask);
3465
    wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3466
    wf_op("\tCPU->flag_notZ = res;\n");
3467
    
3468
    // write
3469
    _ea_write(current_ea, current_op->reg_sft);
3470

3471
    terminate_op(8);
3472
}
3473

3474
static void GenLSR()
3475
{
3476
    set_current_size(SIZE_WORD);        // dst = mem (word operation)
3477
    start_all(GEN_ADR | GEN_RES | GEN_SRC);
3478

3479
    // read
3480
    _ea_calc(current_ea, current_op->reg_sft);
3481
    _ea_read_src(current_ea, current_op->reg_sft);
3482

3483
    // op & flag calculation
3484
    wf_op("\tCPU->flag_N = CPU->flag_V = 0;\n");
3485
    wf_op("\tCPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT;\n");
3486
    wf_op("\tres = src >> 1;\n");
3487
    wf_op("\tCPU->flag_notZ = res;\n");
3488

3489
    // write
3490
    _ea_write(current_ea, current_op->reg_sft);
3491

3492
    terminate_op(8);
3493
}
3494

3495
static void GenROXR()
3496
{
3497
    set_current_size(SIZE_WORD);        // dst = mem (word operation)
3498
    start_all(GEN_ADR | GEN_RES | GEN_SRC);
3499

3500
    // read
3501
    _ea_calc(current_ea, current_op->reg_sft);
3502
    _ea_read_src(current_ea, current_op->reg_sft);
3503

3504
    // op & flag calculation
3505
    wf_op("\tCPU->flag_V = 0;\n");
3506
    wf_op("\tres = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << %d);\n", current_sft_mask - C68K_SR_X_SFT);
3507
    wf_op("\tCPU->flag_C = CPU->flag_X = src << C68K_SR_C_SFT;\n");
3508
    wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3509
    wf_op("\tCPU->flag_notZ = res;\n");
3510

3511
    // write
3512
    _ea_write(current_ea, current_op->reg_sft);
3513

3514
    terminate_op(8);
3515
}
3516

3517
static void GenROR()
3518
{
3519
    set_current_size(SIZE_WORD);        // dst = mem (word operation)
3520
    start_all(GEN_ADR | GEN_RES | GEN_SRC);
3521

3522
    // read
3523
    _ea_calc(current_ea, current_op->reg_sft);
3524
    _ea_read_src(current_ea, current_op->reg_sft);
3525

3526
    // op & flag calculation
3527
    wf_op("\tCPU->flag_V = 0;\n");
3528
    wf_op("\tCPU->flag_C = src << C68K_SR_C_SFT;\n");
3529
    wf_op("\tres = (src >> 1) | (src << %d);\n", current_sft_mask);
3530
    wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3531
    wf_op("\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask);
3532

3533
    // write
3534
    _ea_write(current_ea, current_op->reg_sft);
3535

3536
    terminate_op(8);
3537
}
3538

3539
static void GenASL()
3540
{
3541
    set_current_size(SIZE_WORD);        // dst = mem (word operation)
3542
    start_all(GEN_ADR | GEN_RES | GEN_SRC);
3543

3544
    // read
3545
    _ea_calc(current_ea, current_op->reg_sft);
3546
    _ea_read_src(current_ea, current_op->reg_sft);
3547

3548
    // op & flag calculation
3549
    wf_op("\tCPU->flag_X = CPU->flag_C = src >> %d;\n", current_sft_mask - C68K_SR_C_SFT);
3550
    wf_op("\tres = src << 1;\n");
3551
    wf_op("\tCPU->flag_V = (src ^ res) >> %d;\n", current_sft_mask - C68K_SR_V_SFT);
3552
    wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3553
    wf_op("\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask);
3554

3555
    // write
3556
    _ea_write(current_ea, current_op->reg_sft);
3557

3558
    terminate_op(8);
3559
}
3560

3561
static void GenLSL()
3562
{
3563
    set_current_size(SIZE_WORD);        // dst = mem (word operation)
3564
    start_all(GEN_ADR | GEN_RES | GEN_SRC);
3565

3566
    // read
3567
    _ea_calc(current_ea, current_op->reg_sft);
3568
    _ea_read_src(current_ea, current_op->reg_sft);
3569

3570
    // op & flag calculation
3571
    wf_op("\tCPU->flag_V = 0;\n");
3572
    wf_op("\tCPU->flag_X = CPU->flag_C = src >> %d;\n", current_sft_mask - C68K_SR_C_SFT);
3573
    wf_op("\tres = src << 1;\n");
3574
    wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3575
    wf_op("\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask);
3576

3577
    // write
3578
    _ea_write(current_ea, current_op->reg_sft);
3579

3580
    terminate_op(8);
3581
}
3582

3583
static void GenROXL()
3584
{
3585
    set_current_size(SIZE_WORD);        // dst = mem (word operation)
3586
    start_all(GEN_ADR | GEN_RES | GEN_SRC);
3587

3588
    // read
3589
    _ea_calc(current_ea, current_op->reg_sft);
3590
    _ea_read_src(current_ea, current_op->reg_sft);
3591

3592
    // op & flag calculation
3593
    wf_op("\tCPU->flag_V = 0;\n");
3594
    wf_op("\tres = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> %d);\n", C68K_SR_X_SFT);
3595
    wf_op("\tCPU->flag_X = CPU->flag_C = src >> %d;\n", current_sft_mask - C68K_SR_C_SFT);
3596
    wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3597
    wf_op("\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask);
3598

3599
    // write
3600
    _ea_write(current_ea, current_op->reg_sft);
3601

3602
    terminate_op(8);
3603
}
3604

3605
static void GenROL()
3606
{
3607
    set_current_size(SIZE_WORD);        // dst = mem (word operation)
3608
    start_all(GEN_ADR | GEN_RES | GEN_SRC);
3609

3610
    // read
3611
    _ea_calc(current_ea, current_op->reg_sft);
3612
    _ea_read_src(current_ea, current_op->reg_sft);
3613

3614
    // op & flag calculation
3615
    wf_op("\tCPU->flag_V = 0;\n");
3616
    wf_op("\tCPU->flag_C = src >> %d;\n", current_sft_mask - C68K_SR_C_SFT);
3617
    wf_op("\tres = (src << 1) | (src >> %d);\n", current_sft_mask);
3618
    wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT);
3619
    wf_op("\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask);
3620

3621
    // write
3622
    _ea_write(current_ea, current_op->reg_sft);
3623

3624
    terminate_op(8);
3625
}
3626

3627
static void Gen1010()
3628
{
3629
    u32 base;
3630
    base = get_current_opcode_base();
3631

3632
    // generate jump table
3633
    gen_opjumptable_ext(base, 0x0000, 0x0FFF, 0x1, base);
3634

3635
    // generate label & declarations
3636
    start_op(base, GEN_RES);
3637
    wf_op("\tPC -= 2;\n");
3638
    gen_exception("\t", "C68K_1010_EX");
3639
    terminate_op(4);
3640
}
3641

3642
static void Gen1111()
3643
{
3644
    u32 base;
3645
    base = get_current_opcode_base();
3646

3647
    // generate jump table
3648
    gen_opjumptable_ext(base, 0x0000, 0x0FFF, 0x1, base);
3649

3650
    // generate label & declarations
3651
    start_op(base, GEN_RES);
3652
    wf_op("\tPC -= 2;\n");
3653
    gen_exception("\t", "C68K_1111_EX");
3654
    terminate_op(4);
3655
}
3656

3657
#ifdef NEOCD_HLE
3658
static void Gen0xFABE()
3659
{
3660
    start_all(GEN_ALL);
3661

3662
    wf_op("\tneogeo_exit();\n");
3663

3664
    terminate_op(0);
3665
}
3666

3667
static void Gen0xFABF()
3668
{
3669
    start_all(GEN_ALL);
3670

3671
    wf_op("\timg_display = 1;\n");
3672
    wf_op("\tcdrom_load_files();\n");
3673

3674
    terminate_op(0);
3675
}
3676

3677
static void Gen0xFAC0()
3678
{
3679
    start_all(GEN_ALL);
3680

3681
    wf_op("\timg_display = 0;\n");
3682
    wf_op("\tcdrom_load_files();\n");
3683

3684
    terminate_op(0);
3685
}
3686

3687
static void Gen0xFAC1()
3688
{
3689
    start_all(GEN_ALL);
3690

3691
    wf_op("\tneogeo_upload();\n");
3692

3693
    terminate_op(0);
3694
}
3695

3696
static void Gen0xFAC2()
3697
{
3698
    start_all(GEN_ALL);
3699

3700
    wf_op("\tneogeo_prio_switch();\n");
3701

3702
    terminate_op(0);
3703
}
3704

3705
static void Gen0xFAC3()
3706
{
3707
    start_all(GEN_ALL);
3708

3709
    wf_op("\tneogeo_cdda_control();\n");
3710

3711
    terminate_op(0);
3712
}
3713
#endif
3714

3715

3716
// main function
3717
/////////////////
3718
int main(void)
3719
{
3720
    u32 i;
3721
    u32 s;
3722
    u32 smax;
3723
    
3724
    // clear opcode files
3725
    for(i = 0; i < 0x10; i++)
3726
    {
3727
        char fn[16];
3728
        
3729
        sprintf(fn, "c68k_op%.1X.inc", (int)i);
3730
        opcode_file = fopen(fn, "wt");
3731
        if (opcode_file != NULL)
3732
        {
3733
            fclose(opcode_file);
3734
            opcode_file = NULL;
3735
        }
3736
    }
3737

3738
    // init opcode jump table
3739
    ini_file = fopen("c68k_ini.inc", "wt");
3740
#ifndef C68K_NO_JUMP_TABLE
3741
#ifdef C68K_CONST_JUMP_TABLE
3742
    for(i = 0; i < 0x10000; i++) op_jump_table[i] = OP_ILLEGAL;
3743
#else
3744
    // defaut ILLEGAL instruction
3745
    gen_jumptable(0x0000, 0x0000, 0xFFFF, 1, 0, 0, 0, 0, 0, 0, 0x4AFC);
3746
#endif
3747
#endif
3748
    // generate opcode files
3749
    for(i = 0; i < OP_INFO_TABLE_LEN; i++)
3750
    {
3751
        current_op = &(op_info_table[i]);
3752
        if (prepare_generate()) return 1;
3753

3754
        // s = size to start
3755
        current_size = 0;
3756
        smax = SIZE_LONG;
3757
        if (current_op->size_type == 0) smax = 0;
3758
        else if (current_op->size_type == 1) current_size = 1;
3759
        
3760
        for(s = current_size; s <= smax; s++)
3761
        {
3762
            if (current_op->eam_sft != -1)
3763
            {
3764
                for(current_ea = 0; current_ea <= EA_ADEC7; current_ea++)
3765
                {
3766
                    if (!has_ea(current_ea)) continue;
3767
                    current_eam = _ea_to_eamreg(current_ea) >> 3;
3768
                    current_reg = _ea_to_eamreg(current_ea) & 7;
3769
                    
3770
                    if (op_info_table[i].eam2_sft != -1)
3771
                    {
3772
                        for(current_ea2 = 0; current_ea2 <= EA_ADEC7; current_ea2++)
3773
                        {
3774
                            if (!has_ea2(current_ea2)) continue;
3775
                            current_eam2 = _ea_to_eamreg(current_ea2) >> 3;
3776
                            current_reg2 = _ea_to_eamreg(current_ea2) & 7;
3777
                            
3778
                            set_current_size(s);
3779
                            current_op->genfunc();
3780
                        }
3781
                    }
3782
                    else
3783
                    {
3784
                        current_reg2 = 0;
3785
                        set_current_size(s);
3786
                        current_op->genfunc();
3787
                    }
3788
                }
3789
            }
3790
            else
3791
            {
3792
                current_reg = 0;
3793
                set_current_size(s);
3794
                current_op->genfunc();
3795
            }
3796
        }
3797
    }
3798

3799
    // generate jumptable file
3800
#ifdef C68K_CONST_JUMP_TABLE
3801
    if (ini_file != NULL)
3802
    {
3803
        fprintf(ini_file, "\tstatic const void *JumpTable[0x10000] =\n");
3804
        fprintf(ini_file, "\t{\n");
3805
        
3806
        for(i = 0; i < (0x10000 - 4); i += 4)
3807
            fprintf(ini_file, "\t\t&&OP_0x%.4X, &&OP_0x%.4X, &&OP_0x%.4X, &&OP_0x%.4X,\n", op_jump_table[i + 0], op_jump_table[i + 1], op_jump_table[i + 2], op_jump_table[i + 3]);
3808
        fprintf(ini_file, "\t\t&&OP_0x%.4X, &&OP_0x%.4X, &&OP_0x%.4X, &&OP_0x%.4X\n", op_jump_table[0xFFFC], op_jump_table[0xFFFD], op_jump_table[0xFFFE], op_jump_table[0xFFFF]);
3809
        
3810
        fprintf(ini_file, "\t};\n\n");
3811
    }
3812
#endif
3813

3814
    // close handle
3815
    if (ini_file != NULL) fclose(ini_file);
3816
    if (opcode_file != NULL) fclose(opcode_file);
3817

3818
	return 0;
3819
}
3820
#endif
3821

3822
Product

Resources

Company
