Return to dsp_disasm.c CVS log

Up to [HATARI the Atari ST Emulator] / hatari / src / falcon

Annotation of hatari/src/falcon/dsp_disasm.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *  Dsp56K disassembler
        !             3:  *
        !             4:  *  ARAnyM (C) 2003 Patrice Mandin
        !             5:  *  Adaption to Hatari (C) 2006 by Thomas Huth
        !             6:  *
        !             7:  *  This program is free software; you can redistribute it and/or modify
        !             8:  *  it under the terms of the GNU General Public License as published by
        !             9:  *  the Free Software Foundation; either version 2 of the License, or
        !            10:  *  (at your option) any later version.
        !            11:  *
        !            12:  *  This program is distributed in the hope that it will be useful,
        !            13:  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            14:  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            15:  *  GNU General Public License for more details.
        !            16:  *
        !            17:  *  You should have received a copy of the GNU General Public License
        !            18:  *  along with this program; if not, write to the Free Software
        !            19:  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
        !            20:  */
        !            21: 
        !            22: #include "main.h"
        !            23: #include "sysdeps.h"
        !            24: #include "ioMem.h"
        !            25: #include "dsp.h"
        !            26: #include "dsp_cpu.h"
        !            27: #include "dsp_disasm.h"
        !            28: 
        !            29: #if DEBUG
        !            30: #define D(x) x
        !            31: #else
        !            32: #define D(x)
        !            33: #endif
        !            34: 
        !            35: /* More disasm infos, if wanted */
        !            36: #define DSP_DISASM_REG_PC 0
        !            37: 
        !            38: /**********************************
        !            39:  *     Defines
        !            40:  **********************************/
        !            41: 
        !            42: #define BITMASK(x)     ((1<<(x))-1)
        !            43: 
        !            44: /**********************************
        !            45:  *     Variables
        !            46:  **********************************/
        !            47: 
        !            48: /* Current instruction */
        !            49: static uint32 cur_inst;
        !            50: 
        !            51: /**********************************
        !            52:  *     Register change
        !            53:  **********************************/
        !            54: 
        !            55: static uint32 registers_save[64];
        !            56: static uint32 registers_changed[64];
        !            57: #if DSP_DISASM_REG_PC
        !            58: static uint32 pc_save;
        !            59: #endif
        !            60: 
        !            61: static const char *registers_name[64]={
        !            62:        "","","","",
        !            63:        "x0","x1","y0","y1",
        !            64:        "a0","b0","a2","b2",
        !            65:        "a1","b1","a","b",
        !            66:        
        !            67:        "r0","r1","r2","r3",
        !            68:        "r4","r5","r6","r7",
        !            69:        "n0","n1","n2","n3",
        !            70:        "n4","n5","n6","n7",
        !            71: 
        !            72:        "m0","m1","m2","m3",
        !            73:        "m4","m5","m6","m7",
        !            74:        "","","","",
        !            75:        "","","","",
        !            76: 
        !            77:        "","","","",
        !            78:        "","","","",
        !            79:        "","sr","omr","sp",
        !            80:        "ssh","ssl","la","lc"
        !            81: };
        !            82: 
        !            83: void dsp56k_disasm_reg_read(void)
        !            84: {
        !            85:        memcpy(registers_save, dsp_registers , sizeof(registers_save));
        !            86:        memset(registers_changed, 0, sizeof(registers_changed));
        !            87: #if DSP_DISASM_REG_PC
        !            88:        pc_save = dsp_pc;
        !            89: #endif
        !            90: }
        !            91: 
        !            92: void dsp56k_disasm_reg_compare(void)
        !            93: {
        !            94:        int i;
        !            95:        
        !            96:        for (i=0;i<64;i++) {
        !            97:                if (!registers_changed[i]) {
        !            98:                        continue;
        !            99:                }
        !           100: 
        !           101:                switch(i) {
        !           102:                        case DSP_REG_X0:
        !           103:                        case DSP_REG_X1:
        !           104:                        case DSP_REG_Y0:
        !           105:                        case DSP_REG_Y1:
        !           106:                        case DSP_REG_A0:
        !           107:                        case DSP_REG_A1:
        !           108:                        case DSP_REG_B0:
        !           109:                        case DSP_REG_B1:
        !           110:                                fprintf(stderr,"Dsp: Reg: %s: 0x%06x -> 0x%06x\n", registers_name[i], registers_save[i] & BITMASK(24), dsp_registers[i]  & BITMASK(24));
        !           111:                                break;
        !           112:                        case DSP_REG_R0:
        !           113:                        case DSP_REG_R1:
        !           114:                        case DSP_REG_R2:
        !           115:                        case DSP_REG_R3:
        !           116:                        case DSP_REG_R4:
        !           117:                        case DSP_REG_R5:
        !           118:                        case DSP_REG_R6:
        !           119:                        case DSP_REG_R7:
        !           120:                        case DSP_REG_M0:
        !           121:                        case DSP_REG_M1:
        !           122:                        case DSP_REG_M2:
        !           123:                        case DSP_REG_M3:
        !           124:                        case DSP_REG_M4:
        !           125:                        case DSP_REG_M5:
        !           126:                        case DSP_REG_M6:
        !           127:                        case DSP_REG_M7:
        !           128:                        case DSP_REG_N0:
        !           129:                        case DSP_REG_N1:
        !           130:                        case DSP_REG_N2:
        !           131:                        case DSP_REG_N3:
        !           132:                        case DSP_REG_N4:
        !           133:                        case DSP_REG_N5:
        !           134:                        case DSP_REG_N6:
        !           135:                        case DSP_REG_N7:
        !           136:                        case DSP_REG_SR:
        !           137:                        case DSP_REG_LA:
        !           138:                        case DSP_REG_LC:
        !           139:                                fprintf(stderr,"Dsp: Reg: %s: 0x%04x -> 0x%04x\n", registers_name[i], registers_save[i] & BITMASK(16), dsp_registers[i]  & BITMASK(16));
        !           140:                                break;
        !           141:                        case DSP_REG_A2:
        !           142:                        case DSP_REG_B2:
        !           143:                        case DSP_REG_OMR:
        !           144:                        case DSP_REG_SP:
        !           145:                        case DSP_REG_SSH:
        !           146:                        case DSP_REG_SSL:
        !           147:                                fprintf(stderr,"Dsp: Reg: %s: 0x%02x -> 0x%02x\n", registers_name[i], registers_save[i] & BITMASK(8), dsp_registers[i]  & BITMASK(8));
        !           148:                                break;
        !           149:                        case DSP_REG_A:
        !           150:                        case DSP_REG_B:
        !           151:                                {
        !           152:                                        fprintf(stderr,"Dsp: Reg: %s: 0x%02x:%06x:%06x -> 0x%02x:%06x:%06x\n",
        !           153:                                                registers_name[i],
        !           154:                                                registers_save[DSP_REG_A2+(i & 1)] & BITMASK(8),
        !           155:                                                registers_save[DSP_REG_A1+(i & 1)] & BITMASK(24),
        !           156:                                                registers_save[DSP_REG_A0+(i & 1)] & BITMASK(24),
        !           157:                                                dsp_registers[DSP_REG_A2+(i & 1)]  & BITMASK(8),
        !           158:                                                dsp_registers[DSP_REG_A1+(i & 1)]  & BITMASK(24),
        !           159:                                                dsp_registers[DSP_REG_A0+(i & 1)]  & BITMASK(24)
        !           160:                                        );
        !           161:                                }
        !           162:                                break;
        !           163:                }
        !           164:        }
        !           165: #if DSP_DISASM_REG_PC
        !           166:        if (pc_save != dsp_pc) {
        !           167:                fprintf(stderr,"Dsp: Reg: pc: 0x%04x -> 0x%04x\n", pc_save, dsp_pc);
        !           168:        }
        !           169: #endif
        !           170: }
        !           171: 
        !           172: /**********************************
        !           173:  *     Opcode disassembler
        !           174:  **********************************/
        !           175: 
        !           176: typedef void (*dsp_emul_t)(void);
        !           177: 
        !           178: static void opcode8h_0(void);
        !           179: static void opcode8h_1(void);
        !           180: static void opcode8h_4(void);
        !           181: static void opcode8h_6(void);
        !           182: static void opcode8h_8(void);
        !           183: static void opcode8h_a(void);
        !           184: static void opcode8h_b(void);
        !           185: 
        !           186: static int dsp_calc_ea(uint32 ea_mode, char *dest);
        !           187: static void dsp_calc_cc(uint32 cc_mode, char *dest);
        !           188: static void dsp_undefined(void);
        !           189: 
        !           190: /* Instructions without parallel moves */
        !           191: static void dsp_andi(void);
        !           192: static void dsp_bchg(void);
        !           193: static void dsp_bclr(void);
        !           194: static void dsp_bset(void);
        !           195: static void dsp_btst(void);
        !           196: static void dsp_div(void);
        !           197: static void dsp_do(void);
        !           198: static void dsp_enddo(void);
        !           199: static void dsp_illegal(void);
        !           200: static void dsp_jcc(void);
        !           201: static void dsp_jclr(void);
        !           202: static void dsp_jmp(void);
        !           203: static void dsp_jscc(void);
        !           204: static void dsp_jsclr(void);
        !           205: static void dsp_jset(void);
        !           206: static void dsp_jsr(void);
        !           207: static void dsp_jsset(void);
        !           208: static void dsp_lua(void);
        !           209: static void dsp_movec(void);
        !           210: static void dsp_movem(void);
        !           211: static void dsp_movep(void);
        !           212: static void dsp_nop(void);
        !           213: static void dsp_norm(void);
        !           214: static void dsp_ori(void);
        !           215: static void dsp_rep(void);
        !           216: static void dsp_reset(void);
        !           217: static void dsp_rti(void);
        !           218: static void dsp_rts(void);
        !           219: static void dsp_stop(void);
        !           220: static void dsp_swi(void);
        !           221: static void dsp_tcc(void);
        !           222: static void dsp_wait(void);
        !           223: 
        !           224: static void dsp_do_0(void);
        !           225: static void dsp_do_2(void);
        !           226: static void dsp_do_4(void);
        !           227: static void dsp_do_c(void);
        !           228: static void dsp_movec_7(void);
        !           229: static void dsp_movec_9(void);
        !           230: static void dsp_movec_b(void);
        !           231: static void dsp_movec_d(void);
        !           232: static void dsp_movep_0(void);
        !           233: static void dsp_movep_1(void);
        !           234: static void dsp_movep_2(void);
        !           235: static void dsp_rep_1(void);
        !           236: static void dsp_rep_3(void);
        !           237: static void dsp_rep_5(void);
        !           238: static void dsp_rep_d(void);
        !           239: 
        !           240: /* Parallel moves */
        !           241: static void dsp_pm(void);
        !           242: static void dsp_pm_0(void);
        !           243: static void dsp_pm_1(void);
        !           244: static void dsp_pm_2(void);
        !           245: static void dsp_pm_4(void);
        !           246: static void dsp_pm_8(void);
        !           247: 
        !           248: /* Instructions with parallel moves */
        !           249: static void dsp_abs(void);
        !           250: static void dsp_adc(void);
        !           251: static void dsp_add(void);
        !           252: static void dsp_addl(void);
        !           253: static void dsp_addr(void);
        !           254: static void dsp_and(void);
        !           255: static void dsp_asl(void);
        !           256: static void dsp_asr(void);
        !           257: static void dsp_clr(void);
        !           258: static void dsp_cmp(void);
        !           259: static void dsp_cmpm(void);
        !           260: static void dsp_eor(void);
        !           261: static void dsp_lsl(void);
        !           262: static void dsp_lsr(void);
        !           263: static void dsp_mac(void);
        !           264: static void dsp_macr(void);
        !           265: static void dsp_move(void);
        !           266: static void dsp_move_nopm(void);
        !           267: static void dsp_mpy(void);
        !           268: static void dsp_mpyr(void);
        !           269: static void dsp_neg(void);
        !           270: static void dsp_not(void);
        !           271: static void dsp_or(void);
        !           272: static void dsp_rnd(void);
        !           273: static void dsp_rol(void);
        !           274: static void dsp_ror(void);
        !           275: static void dsp_sbc(void);
        !           276: static void dsp_sub(void);
        !           277: static void dsp_subl(void);
        !           278: static void dsp_subr(void);
        !           279: static void dsp_tfr(void);
        !           280: static void dsp_tst(void);
        !           281: 
        !           282: static dsp_emul_t opcodes8h[16]={
        !           283:        opcode8h_0,
        !           284:        opcode8h_1,
        !           285:        dsp_tcc,
        !           286:        dsp_tcc,
        !           287:        opcode8h_4,
        !           288:        dsp_movec,
        !           289:        opcode8h_6,
        !           290:        dsp_movem,
        !           291:        opcode8h_8,
        !           292:        opcode8h_8,
        !           293:        opcode8h_a,
        !           294:        opcode8h_b,
        !           295:        dsp_jmp,
        !           296:        dsp_jsr,
        !           297:        dsp_jcc,
        !           298:        dsp_jscc
        !           299: };
        !           300: 
        !           301: static dsp_emul_t opcodes_0809[16]={
        !           302:        dsp_move_nopm,
        !           303:        dsp_move_nopm,
        !           304:        dsp_move_nopm,
        !           305:        dsp_move_nopm,
        !           306: 
        !           307:        dsp_movep,
        !           308:        dsp_movep,
        !           309:        dsp_movep,
        !           310:        dsp_movep,
        !           311: 
        !           312:        dsp_move_nopm,
        !           313:        dsp_move_nopm,
        !           314:        dsp_move_nopm,
        !           315:        dsp_move_nopm,
        !           316: 
        !           317:        dsp_movep,
        !           318:        dsp_movep,
        !           319:        dsp_movep,
        !           320:        dsp_movep
        !           321: };
        !           322: 
        !           323: static dsp_emul_t opcodes_0a[32]={
        !           324:        dsp_bclr,
        !           325:        dsp_bset,
        !           326:        dsp_bclr,
        !           327:        dsp_bset,
        !           328:        dsp_jclr,
        !           329:        dsp_jset,
        !           330:        dsp_jclr,
        !           331:        dsp_jset,
        !           332: 
        !           333:        dsp_bclr,
        !           334:        dsp_bset,
        !           335:        dsp_bclr,
        !           336:        dsp_bset,
        !           337:        dsp_jclr,
        !           338:        dsp_jset,
        !           339:        dsp_jclr,
        !           340:        dsp_jset,
        !           341: 
        !           342:        dsp_bclr,
        !           343:        dsp_bset,
        !           344:        dsp_bclr,
        !           345:        dsp_bset,
        !           346:        dsp_jclr,
        !           347:        dsp_jset,
        !           348:        dsp_jclr,
        !           349:        dsp_jset,
        !           350: 
        !           351:        dsp_jclr,
        !           352:        dsp_jset,
        !           353:        dsp_bclr,
        !           354:        dsp_bset,
        !           355:        dsp_jmp,
        !           356:        dsp_jcc,
        !           357:        dsp_undefined,
        !           358:        dsp_undefined
        !           359: };
        !           360: 
        !           361: static dsp_emul_t opcodes_0b[32]={
        !           362:        dsp_bchg,
        !           363:        dsp_btst,
        !           364:        dsp_bchg,
        !           365:        dsp_btst,
        !           366:        dsp_jsclr,
        !           367:        dsp_jsset,
        !           368:        dsp_jsclr,
        !           369:        dsp_jsset,
        !           370: 
        !           371:        dsp_bchg,
        !           372:        dsp_btst,
        !           373:        dsp_bchg,
        !           374:        dsp_btst,
        !           375:        dsp_jsclr,
        !           376:        dsp_jsset,
        !           377:        dsp_jsclr,
        !           378:        dsp_jsset,
        !           379: 
        !           380:        dsp_bchg,
        !           381:        dsp_btst,
        !           382:        dsp_bchg,
        !           383:        dsp_btst,
        !           384:        dsp_jsclr,
        !           385:        dsp_jsset,
        !           386:        dsp_jsclr,
        !           387:        dsp_jsset,
        !           388: 
        !           389:        dsp_jsclr,
        !           390:        dsp_jsclr,
        !           391:        dsp_bchg,
        !           392:        dsp_btst,
        !           393:        dsp_jsr,
        !           394:        dsp_jscc,
        !           395:        dsp_undefined,
        !           396:        dsp_undefined
        !           397: };
        !           398: 
        !           399: static dsp_emul_t opcodes_alu003f[64]={
        !           400:        /* 0x00 - 0x0f */
        !           401:        dsp_move,
        !           402:        dsp_tfr,
        !           403:        dsp_addr,
        !           404:        dsp_tst,
        !           405:        dsp_undefined,
        !           406:        dsp_cmp,
        !           407:        dsp_subr,
        !           408:        dsp_cmpm,
        !           409:        dsp_undefined,
        !           410:        dsp_tfr,
        !           411:        dsp_addr,
        !           412:        dsp_tst,
        !           413:        dsp_undefined,
        !           414:        dsp_cmp,
        !           415:        dsp_subr,
        !           416:        dsp_cmpm,
        !           417: 
        !           418:        /* 0x10 - 0x1f */
        !           419:        dsp_add,
        !           420:        dsp_rnd,
        !           421:        dsp_addl,
        !           422:        dsp_clr,
        !           423:        dsp_sub,
        !           424:        dsp_undefined,
        !           425:        dsp_subl,
        !           426:        dsp_not,
        !           427:        dsp_add,
        !           428:        dsp_rnd,
        !           429:        dsp_addl,
        !           430:        dsp_clr,
        !           431:        dsp_sub,
        !           432:        dsp_undefined,
        !           433:        dsp_subl,
        !           434:        dsp_not,
        !           435: 
        !           436:        /* 0x20 - 0x2f */
        !           437:        dsp_add,
        !           438:        dsp_adc,
        !           439:        dsp_asr,
        !           440:        dsp_lsr,
        !           441:        dsp_sub,
        !           442:        dsp_sbc,
        !           443:        dsp_abs,
        !           444:        dsp_ror,
        !           445:        dsp_add,
        !           446:        dsp_adc,
        !           447:        dsp_asr,
        !           448:        dsp_lsr,
        !           449:        dsp_sub,
        !           450:        dsp_sbc,
        !           451:        dsp_abs,
        !           452:        dsp_ror,
        !           453: 
        !           454:        /* 0x30 - 0x3f */
        !           455:        dsp_add,
        !           456:        dsp_adc,
        !           457:        dsp_asl,
        !           458:        dsp_lsl,
        !           459:        dsp_sub,
        !           460:        dsp_sbc,
        !           461:        dsp_neg,
        !           462:        dsp_rol,
        !           463:        dsp_add,
        !           464:        dsp_adc,
        !           465:        dsp_asl,
        !           466:        dsp_lsl,
        !           467:        dsp_sub,
        !           468:        dsp_sbc,
        !           469:        dsp_neg,
        !           470:        dsp_rol
        !           471: };
        !           472: 
        !           473: static dsp_emul_t opcodes_alu407f[16]={
        !           474:        dsp_add,
        !           475:        dsp_tfr,
        !           476:        dsp_or,
        !           477:        dsp_eor,
        !           478:        dsp_sub,
        !           479:        dsp_cmp,
        !           480:        dsp_and,
        !           481:        dsp_cmpm,
        !           482:        dsp_add,
        !           483:        dsp_tfr,
        !           484:        dsp_or,
        !           485:        dsp_eor,
        !           486:        dsp_sub,
        !           487:        dsp_cmp,
        !           488:        dsp_and,
        !           489:        dsp_cmpm
        !           490: };
        !           491: 
        !           492: static dsp_emul_t opcodes_alu80ff[4]={
        !           493:        dsp_mpy,
        !           494:        dsp_mpyr,
        !           495:        dsp_mac,
        !           496:        dsp_macr
        !           497: };
        !           498: 
        !           499: static dsp_emul_t opcodes_do[16]={
        !           500:        dsp_do_0,
        !           501:        dsp_undefined,
        !           502:        dsp_do_2,
        !           503:        dsp_undefined,
        !           504: 
        !           505:        dsp_do_4,
        !           506:        dsp_undefined,
        !           507:        dsp_do_2,
        !           508:        dsp_undefined,
        !           509: 
        !           510:        dsp_undefined,
        !           511:        dsp_undefined,
        !           512:        dsp_do_2,
        !           513:        dsp_undefined,
        !           514: 
        !           515:        dsp_do_c,
        !           516:        dsp_undefined,
        !           517:        dsp_do_2,
        !           518:        dsp_undefined
        !           519: };
        !           520: 
        !           521: static dsp_emul_t opcodes_movec[16]={
        !           522:        dsp_undefined,
        !           523:        dsp_undefined,
        !           524:        dsp_undefined,
        !           525:        dsp_undefined,
        !           526: 
        !           527:        dsp_undefined,
        !           528:        dsp_undefined,
        !           529:        dsp_undefined,
        !           530:        dsp_movec_7,
        !           531: 
        !           532:        dsp_undefined,
        !           533:        dsp_movec_9,
        !           534:        dsp_undefined,
        !           535:        dsp_movec_b,
        !           536: 
        !           537:        dsp_undefined,
        !           538:        dsp_movec_d,
        !           539:        dsp_undefined,
        !           540:        dsp_movec_b
        !           541: };
        !           542: 
        !           543: static dsp_emul_t opcodes_movep[4]={
        !           544:        dsp_movep_0,
        !           545:        dsp_movep_1,
        !           546:        dsp_movep_2,
        !           547:        dsp_movep_2
        !           548: };
        !           549: 
        !           550: static dsp_emul_t opcodes_rep[16]={
        !           551:        dsp_undefined,
        !           552:        dsp_rep_1,
        !           553:        dsp_undefined,
        !           554:        dsp_rep_3,
        !           555: 
        !           556:        dsp_undefined,
        !           557:        dsp_rep_5,
        !           558:        dsp_undefined,
        !           559:        dsp_rep_3,
        !           560: 
        !           561:        dsp_undefined,
        !           562:        dsp_undefined,
        !           563:        dsp_undefined,
        !           564:        dsp_rep_3,
        !           565: 
        !           566:        dsp_undefined,
        !           567:        dsp_rep_d,
        !           568:        dsp_undefined,
        !           569:        dsp_rep_3
        !           570: };
        !           571: 
        !           572: static dsp_emul_t opcodes_parmove[16]={
        !           573:        dsp_pm_0,
        !           574:        dsp_pm_1,
        !           575:        dsp_pm_2,
        !           576:        dsp_pm_2,
        !           577:        dsp_pm_4,
        !           578:        dsp_pm_4,
        !           579:        dsp_pm_4,
        !           580:        dsp_pm_4,
        !           581: 
        !           582:        dsp_pm_8,
        !           583:        dsp_pm_8,
        !           584:        dsp_pm_8,
        !           585:        dsp_pm_8,
        !           586:        dsp_pm_8,
        !           587:        dsp_pm_8,
        !           588:        dsp_pm_8,
        !           589:        dsp_pm_8
        !           590: };
        !           591: 
        !           592: static int registers_tcc[16][2]={
        !           593:        {DSP_REG_B,DSP_REG_A},
        !           594:        {DSP_REG_A,DSP_REG_B},
        !           595:        {DSP_REG_NULL,DSP_REG_NULL},
        !           596:        {DSP_REG_NULL,DSP_REG_NULL},
        !           597: 
        !           598:        {DSP_REG_NULL,DSP_REG_NULL},
        !           599:        {DSP_REG_NULL,DSP_REG_NULL},
        !           600:        {DSP_REG_NULL,DSP_REG_NULL},
        !           601:        {DSP_REG_NULL,DSP_REG_NULL},
        !           602: 
        !           603:        {DSP_REG_X0,DSP_REG_A},
        !           604:        {DSP_REG_X0,DSP_REG_B},
        !           605:        {DSP_REG_X1,DSP_REG_A},
        !           606:        {DSP_REG_X1,DSP_REG_B},
        !           607: 
        !           608:        {DSP_REG_Y0,DSP_REG_A},
        !           609:        {DSP_REG_Y0,DSP_REG_B},
        !           610:        {DSP_REG_Y1,DSP_REG_A},
        !           611:        {DSP_REG_Y1,DSP_REG_B}
        !           612: };
        !           613: 
        !           614: static const char *registers_lmove[8]={
        !           615:        "a10",
        !           616:        "b10",
        !           617:        "x",
        !           618:        "y",
        !           619:        "a",
        !           620:        "b",
        !           621:        "ab",
        !           622:        "ba"
        !           623: };
        !           624: 
        !           625: static const char *ea_names[9]={
        !           626:        "(r%d)-n%d",    /* 000xxx */
        !           627:        "(r%d)+n%d",    /* 001xxx */
        !           628:        "(r%d)-",               /* 010xxx */
        !           629:        "(r%d)+",               /* 011xxx */
        !           630:        "(r%d)",                /* 100xxx */
        !           631:        "(r%d+n%d)",    /* 101xxx */
        !           632:        "0x%04x",               /* 110000 */
        !           633:        "-(r%d)",               /* 111xxx */
        !           634:        "0x%06x"                /* 110100 */
        !           635: };
        !           636: 
        !           637: static const char *cc_name[16]={
        !           638:        "cc",
        !           639:        "ge",
        !           640:        "ne",
        !           641:        "pl",
        !           642:        "nn",
        !           643:        "ec",
        !           644:        "lc",
        !           645:        "gt",
        !           646:        
        !           647:        "cs",
        !           648:        "lt",
        !           649:        "eq",
        !           650:        "mi",
        !           651:        "nr",
        !           652:        "es",
        !           653:        "ls",
        !           654:        "le"
        !           655: };
        !           656: 
        !           657: static char parallelmove_name[64];
        !           658: 
        !           659: void dsp56k_disasm(void)
        !           660: {
        !           661:        uint32 value;
        !           662: 
        !           663:        cur_inst = dsp_ram[DSP_SPACE_P][dsp_pc];
        !           664: 
        !           665: #if 0
        !           666:        if (dsp_pc == 0x728) {
        !           667:                D(bug("Dsp: Disasm: instruction = 0x%06x",cur_inst));
        !           668:        }
        !           669: #endif
        !           670: 
        !           671:        strcpy(parallelmove_name, "");
        !           672: 
        !           673:        value = (cur_inst >> 16) & BITMASK(8);
        !           674:        if (value< 0x10) {
        !           675:                opcodes8h[value]();
        !           676:        } else {
        !           677:                dsp_pm();
        !           678:                value = cur_inst & BITMASK(8);
        !           679:                if (value < 0x40) {
        !           680:                        opcodes_alu003f[value]();
        !           681:                } else if (value < 0x80) {
        !           682:                        value &= BITMASK(4);
        !           683:                        opcodes_alu407f[value]();
        !           684:                } else {
        !           685:                        value &= BITMASK(2);
        !           686:                        opcodes_alu80ff[value]();
        !           687:                }
        !           688:        }
        !           689: }
        !           690: 
        !           691: /**********************************
        !           692:  *     Conditions code calculation
        !           693:  **********************************/
        !           694: 
        !           695: static void dsp_calc_cc(uint32 cc_mode, char *dest)
        !           696: {
        !           697:        strcpy(dest, cc_name[cc_mode & BITMASK(4)]);
        !           698: }
        !           699: 
        !           700: /**********************************
        !           701:  *     Effective address calculation
        !           702:  **********************************/
        !           703: 
        !           704: static int dsp_calc_ea(uint32 ea_mode, char *dest)
        !           705: {
        !           706:        int value, retour, numreg;
        !           707: 
        !           708:        value = (ea_mode >> 3) & BITMASK(3);
        !           709:        numreg = ea_mode & BITMASK(3);
        !           710:        retour = 0;
        !           711:        switch (value) {
        !           712:                case 0:
        !           713:                        /* (Rx)-Nx */
        !           714:                        sprintf(dest, ea_names[value], numreg, numreg);
        !           715:                        registers_changed[DSP_REG_R0+numreg]=1;
        !           716:                        break;
        !           717:                case 1:
        !           718:                        /* (Rx)+Nx */
        !           719:                        sprintf(dest, ea_names[value], numreg, numreg);
        !           720:                        registers_changed[DSP_REG_R0+numreg]=1;
        !           721:                        break;
        !           722:                case 5:
        !           723:                        /* (Rx+Nx) */
        !           724:                        sprintf(dest, ea_names[value], numreg, numreg);
        !           725:                        break;
        !           726:                case 2:
        !           727:                        /* (Rx)- */
        !           728:                        sprintf(dest, ea_names[value], numreg);
        !           729:                        registers_changed[DSP_REG_R0+numreg]=1;
        !           730:                        break;
        !           731:                case 3:
        !           732:                        /* (Rx)+ */
        !           733:                        sprintf(dest, ea_names[value], numreg);
        !           734:                        registers_changed[DSP_REG_R0+numreg]=1;
        !           735:                        break;
        !           736:                case 4:
        !           737:                        /* (Rx) */
        !           738:                        sprintf(dest, ea_names[value], numreg);
        !           739:                        break;
        !           740:                case 7:
        !           741:                        /* -(Rx) */
        !           742:                        sprintf(dest, ea_names[value], numreg);
        !           743:                        registers_changed[DSP_REG_R0+numreg]=1;
        !           744:                        break;
        !           745:                case 6:
        !           746:                        switch ((ea_mode >> 2) & 1) {
        !           747:                                case 0:
        !           748:                                        /* Absolute address */
        !           749:                                        sprintf(dest, ea_names[value], dsp_ram[DSP_SPACE_P][dsp_pc+1]);
        !           750:                                        break;
        !           751:                                case 1:
        !           752:                                        /* Immediate value */
        !           753:                                        sprintf(dest, ea_names[8], dsp_ram[DSP_SPACE_P][dsp_pc+1]);
        !           754:                                        retour = 1;
        !           755:                                        break;
        !           756:                        }
        !           757:                        break;
        !           758:        }
        !           759:        return retour;
        !           760: }
        !           761: 
        !           762: static void opcode8h_0(void)
        !           763: {
        !           764:        uint32 value;
        !           765: 
        !           766:        if (cur_inst <= 0x00008c) {
        !           767:                switch(cur_inst) {
        !           768:                        case 0x000000:
        !           769:                                dsp_nop();
        !           770:                                break;
        !           771:                        case 0x000004:
        !           772:                                dsp_rti();
        !           773:                                break;
        !           774:                        case 0x000005:
        !           775:                                dsp_illegal();
        !           776:                                break;
        !           777:                        case 0x000006:
        !           778:                                dsp_swi();
        !           779:                                break;
        !           780:                        case 0x00000c:
        !           781:                                dsp_rts();
        !           782:                                break;
        !           783:                        case 0x000084:
        !           784:                                dsp_reset();
        !           785:                                break;
        !           786:                        case 0x000086:
        !           787:                                dsp_wait();
        !           788:                                break;
        !           789:                        case 0x000087:
        !           790:                                dsp_stop();
        !           791:                                break;
        !           792:                        case 0x00008c:
        !           793:                                dsp_enddo();
        !           794:                                break;
        !           795:                }
        !           796:        } else {
        !           797:                value = cur_inst & 0xf8;
        !           798:                switch (value) {
        !           799:                        case 0x0000b8:
        !           800:                                dsp_andi();
        !           801:                                break;
        !           802:                        case 0x0000f8:
        !           803:                                dsp_ori();
        !           804:                                break;
        !           805:                }
        !           806:        }
        !           807: }
        !           808: 
        !           809: static void opcode8h_1(void)
        !           810: {
        !           811:        switch(cur_inst & 0xfff8c7) {
        !           812:                case 0x018040:
        !           813:                        dsp_div();
        !           814:                        break;
        !           815:                case 0x01c805:
        !           816:                        dsp_norm();
        !           817:                        break;
        !           818:        }
        !           819: }
        !           820: 
        !           821: static void opcode8h_4(void)
        !           822: {
        !           823:        switch((cur_inst>>5) & BITMASK(3)) {
        !           824:                case 0:
        !           825:                        dsp_lua();
        !           826:                        break;
        !           827:                case 5:
        !           828:                        dsp_movec();
        !           829:                        break;
        !           830:        }
        !           831: }
        !           832: 
        !           833: static void opcode8h_6(void)
        !           834: {
        !           835:        if (cur_inst & (1<<5)) {
        !           836:                dsp_rep();
        !           837:        } else {
        !           838:                dsp_do();
        !           839:        }
        !           840: }
        !           841: 
        !           842: static void opcode8h_8(void)
        !           843: {
        !           844:        uint32 value;
        !           845: 
        !           846:        value = (cur_inst >> 12) & BITMASK(4);
        !           847:        opcodes_0809[value]();
        !           848: }
        !           849: 
        !           850: static void opcode8h_a(void)
        !           851: {
        !           852:        uint32 value;
        !           853:        
        !           854:        value = (cur_inst >> 11) & (BITMASK(2)<<3);
        !           855:        value |= (cur_inst >> 5) & BITMASK(3);
        !           856: 
        !           857:        opcodes_0a[value]();
        !           858: }
        !           859: 
        !           860: static void opcode8h_b(void)
        !           861: {
        !           862:        uint32 value;
        !           863:        
        !           864:        value = (cur_inst >> 11) & (BITMASK(2)<<3);
        !           865:        value |= (cur_inst >> 5) & BITMASK(3);
        !           866: 
        !           867:        opcodes_0b[value]();
        !           868: }
        !           869: 
        !           870: /**********************************
        !           871:  *     Non-parallel moves instructions
        !           872:  **********************************/
        !           873: 
        !           874: static void dsp_undefined(void)
        !           875: {
        !           876:        fprintf(stderr,"Dsp: 0x%04x: 0x%06x unknown instruction\n",dsp_pc, cur_inst);
        !           877: }
        !           878: 
        !           879: static void dsp_andi(void)
        !           880: {
        !           881:        const char *regname;
        !           882: 
        !           883:        switch(cur_inst & BITMASK(2)) {
        !           884:                case 0:
        !           885:                        regname="mr";
        !           886:                        registers_changed[DSP_REG_SR]=1;
        !           887:                        break;
        !           888:                case 1:
        !           889:                        regname="ccr";
        !           890:                        registers_changed[DSP_REG_SR]=1;
        !           891:                        break;
        !           892:                case 2:
        !           893:                        regname="omr";
        !           894:                        registers_changed[DSP_REG_OMR]=1;
        !           895:                        break;
        !           896:                default:
        !           897:                        regname="";
        !           898:                        break;
        !           899:        }
        !           900: 
        !           901:        fprintf(stderr,"Dsp: 0x%04x: andi #0x%02x,%s\n",
        !           902:                dsp_pc,
        !           903:                (cur_inst>>8) & BITMASK(8),
        !           904:                regname
        !           905:        );
        !           906: }
        !           907: 
        !           908: static void dsp_bchg(void)
        !           909: {
        !           910:        char name[16], addr_name[16];
        !           911:        uint32 memspace, value, numbit;
        !           912:        
        !           913:        memspace = (cur_inst>>6) & 1;
        !           914:        value = (cur_inst>>8) & BITMASK(6);
        !           915:        numbit = cur_inst & BITMASK(5);
        !           916: 
        !           917:        switch((cur_inst>>14) & BITMASK(2)) {
        !           918:                case 0:
        !           919:                        /* bchg #n,x:aa */
        !           920:                        /* bchg #n,y:aa */
        !           921:                        if (memspace) {
        !           922:                                sprintf(name,"y:0x%04x",value);
        !           923:                        } else {
        !           924:                                sprintf(name,"x:0x%04x",value);
        !           925:                        }
        !           926:                        break;
        !           927:                case 1:
        !           928:                        /* bchg #n,x:ea */
        !           929:                        /* bchg #n,y:ea */
        !           930:                        dsp_calc_ea(value, addr_name);
        !           931:                        if (memspace) {
        !           932:                                sprintf(name,"y:%s",addr_name);
        !           933:                        } else {
        !           934:                                sprintf(name,"x:%s",addr_name);
        !           935:                        }
        !           936:                        break;
        !           937:                case 2:
        !           938:                        /* bchg #n,x:pp */
        !           939:                        /* bchg #n,y:pp */
        !           940:                        if (memspace) {
        !           941:                                sprintf(name,"y:0x%04x",value+0xffc0);
        !           942:                        } else {
        !           943:                                sprintf(name,"x:0x%04x",value+0xffc0);
        !           944:                        }
        !           945:                        break;
        !           946:                case 3:
        !           947:                        /* bchg #n,R */
        !           948:                        sprintf(name,"%s",registers_name[value]);
        !           949:                        registers_changed[value]=1;
        !           950:                        break;
        !           951:        }
        !           952: 
        !           953:        fprintf(stderr,"Dsp: 0x%04x: bchg #%d,%s\n",dsp_pc, numbit, name);
        !           954: }
        !           955: 
        !           956: static void dsp_bclr(void)
        !           957: {
        !           958:        char name[16], addr_name[16];
        !           959:        uint32 memspace, value, numbit;
        !           960:        
        !           961:        memspace = (cur_inst>>6) & 1;
        !           962:        value = (cur_inst>>8) & BITMASK(6);
        !           963:        numbit = cur_inst & BITMASK(5);
        !           964: 
        !           965:        switch((cur_inst>>14) & BITMASK(2)) {
        !           966:                case 0:
        !           967:                        /* bclr #n,x:aa */
        !           968:                        /* bclr #n,y:aa */
        !           969:                        if (memspace) {
        !           970:                                sprintf(name,"y:0x%04x",value);
        !           971:                        } else {
        !           972:                                sprintf(name,"x:0x%04x",value);
        !           973:                        }
        !           974:                        break;
        !           975:                case 1:
        !           976:                        /* bclr #n,x:ea */
        !           977:                        /* bclr #n,y:ea */
        !           978:                        dsp_calc_ea(value, addr_name);
        !           979:                        if (memspace) {
        !           980:                                sprintf(name,"y:%s",addr_name);
        !           981:                        } else {
        !           982:                                sprintf(name,"x:%s",addr_name);
        !           983:                        }
        !           984:                        break;
        !           985:                case 2:
        !           986:                        /* bclr #n,x:pp */
        !           987:                        /* bclr #n,y:pp */
        !           988:                        if (memspace) {
        !           989:                                sprintf(name,"y:0x%04x",value+0xffc0);
        !           990:                        } else {
        !           991:                                sprintf(name,"x:0x%04x",value+0xffc0);
        !           992:                        }
        !           993:                        break;
        !           994:                case 3:
        !           995:                        /* bclr #n,R */
        !           996:                        sprintf(name,"%s",registers_name[value]);
        !           997:                        registers_changed[value]=1;
        !           998:                        break;
        !           999:        }
        !          1000: 
        !          1001:        fprintf(stderr,"Dsp: 0x%04x: bclr #%d,%s\n",dsp_pc, numbit, name);
        !          1002: }
        !          1003: 
        !          1004: static void dsp_bset(void)
        !          1005: {
        !          1006:        char name[16], addr_name[16];
        !          1007:        uint32 memspace, value, numbit;
        !          1008:        
        !          1009:        memspace = (cur_inst>>6) & 1;
        !          1010:        value = (cur_inst>>8) & BITMASK(6);
        !          1011:        numbit = cur_inst & BITMASK(5);
        !          1012: 
        !          1013:        switch((cur_inst>>14) & BITMASK(2)) {
        !          1014:                case 0:
        !          1015:                        /* bset #n,x:aa */
        !          1016:                        /* bset #n,y:aa */
        !          1017:                        if (memspace) {
        !          1018:                                sprintf(name,"y:0x%04x",value);
        !          1019:                        } else {
        !          1020:                                sprintf(name,"x:0x%04x",value);
        !          1021:                        }
        !          1022:                        break;
        !          1023:                case 1:
        !          1024:                        /* bset #n,x:ea */
        !          1025:                        /* bset #n,y:ea */
        !          1026:                        dsp_calc_ea(value, addr_name);
        !          1027:                        if (memspace) {
        !          1028:                                sprintf(name,"y:%s",addr_name);
        !          1029:                        } else {
        !          1030:                                sprintf(name,"x:%s",addr_name);
        !          1031:                        }
        !          1032:                        break;
        !          1033:                case 2:
        !          1034:                        /* bset #n,x:pp */
        !          1035:                        /* bset #n,y:pp */
        !          1036:                        if (memspace) {
        !          1037:                                sprintf(name,"y:0x%04x",value+0xffc0);
        !          1038:                        } else {
        !          1039:                                sprintf(name,"x:0x%04x",value+0xffc0);
        !          1040:                        }
        !          1041:                        break;
        !          1042:                case 3:
        !          1043:                        /* bset #n,R */
        !          1044:                        sprintf(name,"%s",registers_name[value]);
        !          1045:                        registers_changed[value]=1;
        !          1046:                        break;
        !          1047:        }
        !          1048: 
        !          1049:        fprintf(stderr,"Dsp: 0x%04x: bset #%d,%s\n",dsp_pc, numbit, name);
        !          1050: }
        !          1051: 
        !          1052: static void dsp_btst(void)
        !          1053: {
        !          1054:        char name[16], addr_name[16];
        !          1055:        uint32 memspace, value, numbit;
        !          1056:        
        !          1057:        memspace = (cur_inst>>6) & 1;
        !          1058:        value = (cur_inst>>8) & BITMASK(6);
        !          1059:        numbit = cur_inst & BITMASK(5);
        !          1060: 
        !          1061:        switch((cur_inst>>14) & BITMASK(2)) {
        !          1062:                case 0:
        !          1063:                        /* btst #n,x:aa */
        !          1064:                        /* btst #n,y:aa */
        !          1065:                        if (memspace) {
        !          1066:                                sprintf(name,"y:0x%04x",value);
        !          1067:                        } else {
        !          1068:                                sprintf(name,"x:0x%04x",value);
        !          1069:                        }
        !          1070:                        break;
        !          1071:                case 1:
        !          1072:                        /* btst #n,x:ea */
        !          1073:                        /* btst #n,y:ea */
        !          1074:                        dsp_calc_ea(value, addr_name);
        !          1075:                        if (memspace) {
        !          1076:                                sprintf(name,"y:%s",addr_name);
        !          1077:                        } else {
        !          1078:                                sprintf(name,"x:%s",addr_name);
        !          1079:                        }
        !          1080:                        break;
        !          1081:                case 2:
        !          1082:                        /* btst #n,x:pp */
        !          1083:                        /* btst #n,y:pp */
        !          1084:                        if (memspace) {
        !          1085:                                sprintf(name,"y:0x%04x",value+0xffc0);
        !          1086:                        } else {
        !          1087:                                sprintf(name,"x:0x%04x",value+0xffc0);
        !          1088:                        }
        !          1089:                        break;
        !          1090:                case 3:
        !          1091:                        /* btst #n,R */
        !          1092:                        sprintf(name,"%s",registers_name[value]);
        !          1093:                        registers_changed[value]=1;
        !          1094:                        break;
        !          1095:        }
        !          1096: 
        !          1097:        fprintf(stderr,"Dsp: 0x%04x: btst #%d,%s\n",dsp_pc, numbit, name);
        !          1098: }
        !          1099: 
        !          1100: static void dsp_div(void)
        !          1101: {
        !          1102:        uint32 srcreg=DSP_REG_NULL, destreg;
        !          1103:        
        !          1104:        switch((cur_inst>>4) & BITMASK(2)) {
        !          1105:                case 0:
        !          1106:                        srcreg = DSP_REG_X0;
        !          1107:                                break;
        !          1108:                case 1:
        !          1109:                        srcreg = DSP_REG_Y0;
        !          1110:                                break;
        !          1111:                case 2:
        !          1112:                        srcreg = DSP_REG_X1;
        !          1113:                                break;
        !          1114:                case 3:
        !          1115:                        srcreg = DSP_REG_Y1;
        !          1116:                                break;
        !          1117:        }
        !          1118:        destreg = DSP_REG_A+((cur_inst>>3) & 1);
        !          1119:        registers_changed[destreg]=1;
        !          1120: 
        !          1121:        fprintf(stderr,"Dsp: 0x%04x: div %s,%s\n",dsp_pc, registers_name[srcreg],registers_name[destreg]);
        !          1122: }
        !          1123: 
        !          1124: static void dsp_do(void)
        !          1125: {
        !          1126:        uint32 value;
        !          1127: 
        !          1128:        value = (cur_inst>>12) & (BITMASK(2)<<2);
        !          1129:        value |= (cur_inst>>6) & 1<<1;
        !          1130:        value |= (cur_inst>>5) & 1;
        !          1131: 
        !          1132:        opcodes_do[value]();
        !          1133:        
        !          1134:        registers_changed[DSP_REG_LA]=1;
        !          1135:        registers_changed[DSP_REG_LC]=1;
        !          1136: }
        !          1137: 
        !          1138: static void dsp_do_0(void)
        !          1139: {
        !          1140:        char name[16];
        !          1141: 
        !          1142:        if (cur_inst & (1<<6)) {
        !          1143:                sprintf(name, "y:0x%04x", (cur_inst>>8) & BITMASK(6));
        !          1144:        } else {
        !          1145:                sprintf(name, "x:0x%04x", (cur_inst>>8) & BITMASK(6));
        !          1146:        }
        !          1147: 
        !          1148:        fprintf(stderr,"Dsp: 0x%04x: do %s,p:0x%04x\n",
        !          1149:                dsp_pc,
        !          1150:                name,
        !          1151:                dsp_ram[DSP_SPACE_P][dsp_pc+1] & BITMASK(16)
        !          1152:        );
        !          1153: }
        !          1154: 
        !          1155: static void dsp_do_2(void)
        !          1156: {
        !          1157:        fprintf(stderr,"Dsp: 0x%04x: do #0x%04x,p:0x%04x\n",
        !          1158:                dsp_pc,
        !          1159:                ((cur_inst>>8) & BITMASK(8))|((cur_inst & BITMASK(4))<<8),
        !          1160:                dsp_ram[DSP_SPACE_P][dsp_pc+1] & BITMASK(16)
        !          1161:        );
        !          1162: }
        !          1163: 
        !          1164: static void dsp_do_4(void)
        !          1165: {
        !          1166:        char addr_name[16], name[16];
        !          1167:        uint32 ea_mode;
        !          1168:        
        !          1169:        ea_mode = (cur_inst>>8) & BITMASK(6);
        !          1170:        dsp_calc_ea(ea_mode, addr_name);
        !          1171: 
        !          1172:        if (cur_inst & (1<<6)) {
        !          1173:                sprintf(name, "y:%s", addr_name);
        !          1174:        } else {
        !          1175:                sprintf(name, "x:%s", addr_name);
        !          1176:        }
        !          1177: 
        !          1178:        fprintf(stderr,"Dsp: 0x%04x: do %s,p:0x%04x\n", 
        !          1179:                dsp_pc,
        !          1180:                name,
        !          1181:                dsp_ram[DSP_SPACE_P][dsp_pc+1] & BITMASK(16)
        !          1182:        );
        !          1183: }
        !          1184: 
        !          1185: static void dsp_do_c(void)
        !          1186: {
        !          1187:        fprintf(stderr,"Dsp: 0x%04x: do %s,p:0x%04x\n",
        !          1188:                dsp_pc,
        !          1189:                registers_name[(cur_inst>>8) & BITMASK(6)],
        !          1190:                dsp_ram[DSP_SPACE_P][dsp_pc+1] & BITMASK(16)
        !          1191:        );
        !          1192: }
        !          1193: 
        !          1194: static void dsp_enddo(void)
        !          1195: {
        !          1196:        fprintf(stderr,"Dsp: 0x%04x: enddo\n",dsp_pc);
        !          1197: }
        !          1198: 
        !          1199: static void dsp_illegal(void)
        !          1200: {
        !          1201:        fprintf(stderr,"Dsp: 0x%04x: illegal\n",dsp_pc);
        !          1202: }
        !          1203: 
        !          1204: static void dsp_jcc(void)
        !          1205: {
        !          1206:        char cond_name[16], addr_name[16];
        !          1207:        uint32 cc_code=0;
        !          1208:        
        !          1209:        switch((cur_inst >> 16) & BITMASK(8)) {
        !          1210:                case 0x0a:
        !          1211:                        dsp_calc_ea((cur_inst >>8) & BITMASK(6), addr_name);
        !          1212:                        cc_code=cur_inst & BITMASK(4);
        !          1213:                        break;
        !          1214:                case 0x0e:
        !          1215:                        sprintf(addr_name, "0x%04x", cur_inst & BITMASK(12));
        !          1216:                        cc_code=(cur_inst>>12) & BITMASK(4);
        !          1217:                        break;
        !          1218:        }
        !          1219:        dsp_calc_cc(cc_code, cond_name);        
        !          1220: 
        !          1221:        fprintf(stderr,"Dsp: 0x%04x: j%s p:%s\n",dsp_pc, cond_name, addr_name);
        !          1222: }
        !          1223: 
        !          1224: static void dsp_jclr(void)
        !          1225: {
        !          1226:        char srcname[16], addr_name[16];
        !          1227:        uint32 memspace, value, numbit;
        !          1228:        
        !          1229:        memspace = (cur_inst>>6) & 1;
        !          1230:        value = (cur_inst>>8) & BITMASK(6);
        !          1231:        numbit = cur_inst & BITMASK(5);
        !          1232: 
        !          1233:        switch((cur_inst>>14) & BITMASK(2)) {
        !          1234:                case 0:
        !          1235:                        /* jclr #n,x:aa,p:xx */
        !          1236:                        /* jclr #n,y:aa,p:xx */
        !          1237:                        if (memspace) {
        !          1238:                                sprintf(srcname, "y:0x%04x", value);
        !          1239:                        } else {
        !          1240:                                sprintf(srcname, "x:0x%04x", value);
        !          1241:                        }
        !          1242:                        break;
        !          1243:                case 1:
        !          1244:                        /* jclr #n,x:ea,p:xx */
        !          1245:                        /* jclr #n,y:ea,p:xx */
        !          1246:                        dsp_calc_ea(value, addr_name);
        !          1247:                        if (memspace) {
        !          1248:                                sprintf(srcname, "y:%s", addr_name);
        !          1249:                        } else {
        !          1250:                                sprintf(srcname, "x:%s", addr_name);
        !          1251:                        }
        !          1252:                        break;
        !          1253:                case 2:
        !          1254:                        /* jclr #n,x:pp,p:xx */
        !          1255:                        /* jclr #n,y:pp,p:xx */
        !          1256:                        value += 0xffc0;
        !          1257:                        if (memspace) {
        !          1258:                                sprintf(srcname, "y:0x%04x", value);
        !          1259:                        } else {
        !          1260:                                sprintf(srcname, "x:0x%04x", value);
        !          1261:                        }
        !          1262:                        break;
        !          1263:                case 3:
        !          1264:                        /* jclr #n,R,p:xx */
        !          1265:                        sprintf(srcname, registers_name[value]);
        !          1266:                        break;
        !          1267:        }
        !          1268: 
        !          1269:        fprintf(stderr,"Dsp: 0x%04x: jclr #%d,%s,p:0x%04x\n",
        !          1270:                dsp_pc,
        !          1271:                numbit,
        !          1272:                srcname,
        !          1273:                dsp_ram[DSP_SPACE_P][dsp_pc+1]
        !          1274:        );
        !          1275: }
        !          1276: 
        !          1277: static void dsp_jmp(void)
        !          1278: {
        !          1279:        char dstname[16];
        !          1280: 
        !          1281:        switch((cur_inst >> 16) & BITMASK(8)) {
        !          1282:                case 0x0a:
        !          1283:                        dsp_calc_ea((cur_inst >>8) & BITMASK(6), dstname);
        !          1284:                        break;
        !          1285:                case 0x0c:
        !          1286:                        sprintf(dstname, "0x%04x", cur_inst & BITMASK(12));
        !          1287:                        break;
        !          1288:        }
        !          1289: 
        !          1290:        fprintf(stderr,"Dsp: 0x%04x: jmp p:%s\n",dsp_pc, dstname);
        !          1291: }
        !          1292: 
        !          1293: static void dsp_jscc(void)
        !          1294: {
        !          1295:        char cond_name[16], addr_name[16];
        !          1296:        uint32 cc_code=0;
        !          1297:        
        !          1298:        switch((cur_inst >> 16) & BITMASK(8)) {
        !          1299:                case 0x0b:
        !          1300:                        dsp_calc_ea((cur_inst >>8) & BITMASK(6), addr_name);
        !          1301:                        cc_code=cur_inst & BITMASK(4);
        !          1302:                        break;
        !          1303:                case 0x0f:
        !          1304:                        sprintf(addr_name, "0x%04x", cur_inst & BITMASK(12));
        !          1305:                        cc_code=(cur_inst>>12) & BITMASK(4);
        !          1306:                        break;
        !          1307:        }
        !          1308:        dsp_calc_cc(cc_code, cond_name);        
        !          1309: 
        !          1310:        fprintf(stderr,"Dsp: 0x%04x: js%s p:%s\n",dsp_pc, cond_name, addr_name);
        !          1311: }
        !          1312:        
        !          1313: static void dsp_jsclr(void)
        !          1314: {
        !          1315:        char srcname[16], addr_name[16];
        !          1316:        uint32 memspace, value, numbit;
        !          1317:        
        !          1318:        memspace = (cur_inst>>6) & 1;
        !          1319:        value = (cur_inst>>8) & BITMASK(6);
        !          1320:        numbit = cur_inst & BITMASK(5);
        !          1321: 
        !          1322:        switch((cur_inst>>14) & BITMASK(2)) {
        !          1323:                case 0:
        !          1324:                        /* jsclr #n,x:aa,p:xx */
        !          1325:                        /* jsclr #n,y:aa,p:xx */
        !          1326:                        if (memspace) {
        !          1327:                                sprintf(srcname, "y:0x%04x", value);
        !          1328:                        } else {
        !          1329:                                sprintf(srcname, "x:0x%04x", value);
        !          1330:                        }
        !          1331:                        break;
        !          1332:                case 1:
        !          1333:                        /* jsclr #n,x:ea,p:xx */
        !          1334:                        /* jsclr #n,y:ea,p:xx */
        !          1335:                        dsp_calc_ea(value, addr_name);
        !          1336:                        if (memspace) {
        !          1337:                                sprintf(srcname, "y:%s", addr_name);
        !          1338:                        } else {
        !          1339:                                sprintf(srcname, "x:%s", addr_name);
        !          1340:                        }
        !          1341:                        break;
        !          1342:                case 2:
        !          1343:                        /* jsclr #n,x:pp,p:xx */
        !          1344:                        /* jsclr #n,y:pp,p:xx */
        !          1345:                        value += 0xffc0;
        !          1346:                        if (memspace) {
        !          1347:                                sprintf(srcname, "y:0x%04x", value);
        !          1348:                        } else {
        !          1349:                                sprintf(srcname, "x:0x%04x", value);
        !          1350:                        }
        !          1351:                        break;
        !          1352:                case 3:
        !          1353:                        /* jsclr #n,R,p:xx */
        !          1354:                        sprintf(srcname, registers_name[value]);
        !          1355:                        break;
        !          1356:        }
        !          1357: 
        !          1358:        fprintf(stderr,"Dsp: 0x%04x: jsclr #%d,%s,p:0x%04x\n",
        !          1359:                dsp_pc,
        !          1360:                numbit,
        !          1361:                srcname,
        !          1362:                dsp_ram[DSP_SPACE_P][dsp_pc+1]
        !          1363:        );
        !          1364: }
        !          1365: 
        !          1366: static void dsp_jset(void)
        !          1367: {
        !          1368:        char srcname[16], addr_name[16];
        !          1369:        uint32 memspace, value, numbit;
        !          1370:        
        !          1371:        memspace = (cur_inst>>6) & 1;
        !          1372:        value = (cur_inst>>8) & BITMASK(6);
        !          1373:        numbit = cur_inst & BITMASK(5);
        !          1374: 
        !          1375:        switch((cur_inst>>14) & BITMASK(2)) {
        !          1376:                case 0:
        !          1377:                        /* jset #n,x:aa,p:xx */
        !          1378:                        /* jset #n,y:aa,p:xx */
        !          1379:                        if (memspace) {
        !          1380:                                sprintf(srcname, "y:0x%04x", value);
        !          1381:                        } else {
        !          1382:                                sprintf(srcname, "x:0x%04x", value);
        !          1383:                        }
        !          1384:                        break;
        !          1385:                case 1:
        !          1386:                        /* jset #n,x:ea,p:xx */
        !          1387:                        /* jset #n,y:ea,p:xx */
        !          1388:                        dsp_calc_ea(value, addr_name);
        !          1389:                        if (memspace) {
        !          1390:                                sprintf(srcname, "y:%s", addr_name);
        !          1391:                        } else {
        !          1392:                                sprintf(srcname, "x:%s", addr_name);
        !          1393:                        }
        !          1394:                        break;
        !          1395:                case 2:
        !          1396:                        /* jset #n,x:pp,p:xx */
        !          1397:                        /* jset #n,y:pp,p:xx */
        !          1398:                        value += 0xffc0;
        !          1399:                        if (memspace) {
        !          1400:                                sprintf(srcname, "y:0x%04x", value);
        !          1401:                        } else {
        !          1402:                                sprintf(srcname, "x:0x%04x", value);
        !          1403:                        }
        !          1404:                        break;
        !          1405:                case 3:
        !          1406:                        /* jset #n,R,p:xx */
        !          1407:                        sprintf(srcname, registers_name[value]);
        !          1408:                        break;
        !          1409:        }
        !          1410: 
        !          1411:        fprintf(stderr,"Dsp: 0x%04x: jset #%d,%s,p:0x%04x\n",
        !          1412:                dsp_pc,
        !          1413:                numbit,
        !          1414:                srcname,
        !          1415:                dsp_ram[DSP_SPACE_P][dsp_pc+1]
        !          1416:        );
        !          1417: }
        !          1418: 
        !          1419: static void dsp_jsr(void)
        !          1420: {
        !          1421:        char dstname[16];
        !          1422: 
        !          1423:        if (((cur_inst>>12) & BITMASK(4))==0) {
        !          1424:                sprintf(dstname, "0x%04x", cur_inst & BITMASK(12));
        !          1425:        } else {
        !          1426:                dsp_calc_ea((cur_inst>>8) & BITMASK(6),dstname);
        !          1427:        }
        !          1428: 
        !          1429:        fprintf(stderr,"Dsp: 0x%04x: jsr p:%s\n",dsp_pc, dstname);
        !          1430: }
        !          1431: 
        !          1432: static void dsp_jsset(void)
        !          1433: {
        !          1434:        char srcname[16], addr_name[16];
        !          1435:        uint32 memspace, value, numbit;
        !          1436:        
        !          1437:        memspace = (cur_inst>>6) & 1;
        !          1438:        value = (cur_inst>>8) & BITMASK(6);
        !          1439:        numbit = cur_inst & BITMASK(5);
        !          1440: 
        !          1441:        switch((cur_inst>>14) & BITMASK(2)) {
        !          1442:                case 0:
        !          1443:                        /* jsset #n,x:aa,p:xx */
        !          1444:                        /* jsset #n,y:aa,p:xx */
        !          1445:                        if (memspace) {
        !          1446:                                sprintf(srcname, "y:0x%04x", value);
        !          1447:                        } else {
        !          1448:                                sprintf(srcname, "x:0x%04x", value);
        !          1449:                        }
        !          1450:                        break;
        !          1451:                case 1:
        !          1452:                        /* jsset #n,x:ea,p:xx */
        !          1453:                        /* jsset #n,y:ea,p:xx */
        !          1454:                        dsp_calc_ea(value, addr_name);
        !          1455:                        if (memspace) {
        !          1456:                                sprintf(srcname, "y:%s", addr_name);
        !          1457:                        } else {
        !          1458:                                sprintf(srcname, "x:%s", addr_name);
        !          1459:                        }
        !          1460:                        break;
        !          1461:                case 2:
        !          1462:                        /* jsset #n,x:pp,p:xx */
        !          1463:                        /* jsset #n,y:pp,p:xx */
        !          1464:                        value += 0xffc0;
        !          1465:                        if (memspace) {
        !          1466:                                sprintf(srcname, "y:0x%04x", value);
        !          1467:                        } else {
        !          1468:                                sprintf(srcname, "x:0x%04x", value);
        !          1469:                        }
        !          1470:                        break;
        !          1471:                case 3:
        !          1472:                        /* jsset #n,R,p:xx */
        !          1473:                        sprintf(srcname, registers_name[value]);
        !          1474:                        break;
        !          1475:        }
        !          1476: 
        !          1477:        fprintf(stderr,"Dsp: 0x%04x: jsset #%d,%s,p:0x%04x\n",
        !          1478:                dsp_pc,
        !          1479:                numbit,
        !          1480:                srcname,
        !          1481:                dsp_ram[DSP_SPACE_P][dsp_pc+1]
        !          1482:        );
        !          1483: }
        !          1484: 
        !          1485: static void dsp_lua(void)
        !          1486: {
        !          1487:        char addr_name[16], numreg;
        !          1488: 
        !          1489:        dsp_calc_ea((cur_inst>>8) & BITMASK(5), addr_name);
        !          1490:        numreg = cur_inst & BITMASK(3);
        !          1491:        registers_changed[DSP_REG_R0+numreg]=1;
        !          1492:        
        !          1493:        fprintf(stderr,"Dsp: 0x%04x: lua %s,r%d\n",dsp_pc, addr_name, numreg);
        !          1494: }
        !          1495: 
        !          1496: static void dsp_movec(void)
        !          1497: {
        !          1498:        uint32 value;
        !          1499:        
        !          1500:        value = (cur_inst>>13) & (1<<3);
        !          1501:        value |= (cur_inst>>12) & (1<<2);
        !          1502:        value |= (cur_inst>>6) & (1<<1);
        !          1503:        value |= (cur_inst>>5) & 1;
        !          1504: 
        !          1505:        opcodes_movec[value]();
        !          1506: }
        !          1507: 
        !          1508: static void dsp_movec_7(void)
        !          1509: {
        !          1510:        uint32 numreg1, numreg2;
        !          1511: 
        !          1512:        /* S1,D2 */
        !          1513:        /* S2,D1 */
        !          1514: 
        !          1515:        numreg2 = (cur_inst>>8) & BITMASK(6);
        !          1516:        numreg1 = (cur_inst & BITMASK(5))|0x20;
        !          1517: 
        !          1518:        if (cur_inst & (1<<15)) {
        !          1519:                /* Write D1 */
        !          1520:                fprintf(stderr,"Dsp: 0x%04x: movec %s,%s\n",dsp_pc, registers_name[numreg2], registers_name[numreg1]);
        !          1521:                registers_changed[numreg1]=1;
        !          1522:        } else {
        !          1523:                /* Read S1 */
        !          1524:                fprintf(stderr,"Dsp: 0x%04x: movec %s,%s\n",dsp_pc, registers_name[numreg1], registers_name[numreg2]);
        !          1525:                registers_changed[numreg2]=1;
        !          1526:        }
        !          1527: }
        !          1528: 
        !          1529: static void dsp_movec_9(void)
        !          1530: {
        !          1531:        const char *spacename;
        !          1532:        char srcname[16],dstname[16];
        !          1533:        uint32 numreg, addr;
        !          1534: 
        !          1535:        /* x:aa,D1 */
        !          1536:        /* S1,x:aa */
        !          1537:        /* y:aa,D1 */
        !          1538:        /* S1,y:aa */
        !          1539: 
        !          1540:        numreg = (cur_inst & BITMASK(5))|0x20;
        !          1541:        addr = (cur_inst>>8) & BITMASK(6);
        !          1542: 
        !          1543:        if (cur_inst & (1<<6)) {
        !          1544:                spacename="y";
        !          1545:        } else {
        !          1546:                spacename="x";
        !          1547:        }
        !          1548: 
        !          1549:        if (cur_inst & (1<<15)) {
        !          1550:                /* Write D1 */
        !          1551:                sprintf(srcname, "%s:0x%04x", spacename, addr);
        !          1552:                strcpy(dstname, registers_name[numreg]);
        !          1553:        } else {
        !          1554:                /* Read S1 */
        !          1555:                strcpy(srcname, registers_name[numreg]);
        !          1556:                sprintf(dstname, "%s:0x%04x", spacename, addr);
        !          1557:        }
        !          1558: 
        !          1559:        fprintf(stderr,"Dsp: 0x%04x: movec %s,%s\n",dsp_pc, srcname, dstname);
        !          1560: }
        !          1561: 
        !          1562: static void dsp_movec_b(void)
        !          1563: {
        !          1564:        uint32 numreg;
        !          1565: 
        !          1566:        /* #xx,D1 */
        !          1567: 
        !          1568:        numreg = (cur_inst & BITMASK(5))|0x20;
        !          1569: 
        !          1570:        registers_changed[numreg]=1;
        !          1571:        fprintf(stderr,"Dsp: 0x%04x: movec #0x%02x,%s\n",dsp_pc, (cur_inst>>8) & BITMASK(8), registers_name[numreg]);
        !          1572: }
        !          1573: 
        !          1574: static void dsp_movec_d(void)
        !          1575: {
        !          1576:        const char *spacename;
        !          1577:        char srcname[16], dstname[16], addr_name[16];
        !          1578:        uint32 numreg, ea_mode;
        !          1579:        int retour;
        !          1580: 
        !          1581:        /* x:ea,D1 */
        !          1582:        /* S1,x:ea */
        !          1583:        /* y:ea,D1 */
        !          1584:        /* S1,y:ea */
        !          1585:        /* #xxxx,D1 */
        !          1586: 
        !          1587:        numreg = (cur_inst & BITMASK(5))|0x20;
        !          1588:        ea_mode = (cur_inst>>8) & BITMASK(6);
        !          1589:        retour = dsp_calc_ea(ea_mode, addr_name);
        !          1590: 
        !          1591:        if (cur_inst & (1<<6)) {
        !          1592:                spacename="y";
        !          1593:        } else {
        !          1594:                spacename="x";
        !          1595:        }
        !          1596: 
        !          1597:        if (cur_inst & (1<<15)) {
        !          1598:                /* Write D1 */
        !          1599:                if (retour) {
        !          1600:                        sprintf(srcname, "#%s", addr_name);
        !          1601:                } else {
        !          1602:                        sprintf(srcname, "%s:%s", spacename, addr_name);
        !          1603:                }
        !          1604:                registers_changed[numreg]=1;
        !          1605:                strcpy(dstname, registers_name[numreg]);
        !          1606:        } else {
        !          1607:                /* Read S1 */
        !          1608:                strcpy(srcname, registers_name[numreg]);
        !          1609:                sprintf(dstname, "%s:%s", spacename, addr_name);
        !          1610:        }
        !          1611: 
        !          1612:        fprintf(stderr,"Dsp: 0x%04x: movec %s,%s\n",dsp_pc, srcname, dstname);
        !          1613: }
        !          1614: 
        !          1615: static void dsp_movem(void)
        !          1616: {
        !          1617:        char addr_name[16], srcname[16], dstname[16];
        !          1618:        uint32 ea_mode, numreg;
        !          1619: 
        !          1620:        if (cur_inst & (1<<14)) {
        !          1621:                /* S,p:ea */
        !          1622:                /* p:ea,D */
        !          1623: 
        !          1624:                ea_mode = (cur_inst>>8) & BITMASK(6);
        !          1625:                dsp_calc_ea(ea_mode, addr_name);
        !          1626:        } else {
        !          1627:                /* S,p:aa */
        !          1628:                /* p:aa,D */
        !          1629: 
        !          1630:                sprintf(addr_name, "0x%04x",(cur_inst>>8) & BITMASK(6));
        !          1631:        }
        !          1632: 
        !          1633:        numreg = cur_inst & BITMASK(6);
        !          1634:        if  (cur_inst & (1<<15)) {
        !          1635:                /* Write D */
        !          1636:                registers_changed[numreg]=1;
        !          1637:                sprintf(srcname, "p:%s", addr_name);
        !          1638:                strcpy(dstname, registers_name[numreg]);
        !          1639:        } else {
        !          1640:                /* Read S */
        !          1641:                strcpy(srcname, registers_name[numreg]);
        !          1642:                sprintf(dstname, "p:%s", addr_name);
        !          1643:        }
        !          1644: 
        !          1645:        fprintf(stderr,"Dsp: 0x%04x: movem %s,%s\n",dsp_pc, srcname, dstname);
        !          1646: }
        !          1647: 
        !          1648: static void dsp_movep(void)
        !          1649: {
        !          1650:        uint32 value;
        !          1651:        
        !          1652:        value = (cur_inst>>6) & BITMASK(2);
        !          1653: 
        !          1654:        opcodes_movep[value]();
        !          1655: }
        !          1656: 
        !          1657: static void dsp_movep_0(void)
        !          1658: {
        !          1659:        char srcname[16]="",dstname[16]="";
        !          1660:        uint32 addr, memspace, numreg;
        !          1661: 
        !          1662:        /* S,x:pp */
        !          1663:        /* x:pp,D */
        !          1664:        /* S,y:pp */
        !          1665:        /* y:pp,D */
        !          1666: 
        !          1667:        addr = 0xffc0 + (cur_inst & BITMASK(6));
        !          1668:        memspace = (cur_inst>>16) & 1;
        !          1669:        numreg = (cur_inst>>8) & BITMASK(6);
        !          1670: 
        !          1671:        if (cur_inst & (1<<15)) {
        !          1672:                /* Write pp */
        !          1673: 
        !          1674:                strcpy(srcname, registers_name[numreg]);
        !          1675: 
        !          1676:                if (memspace) {
        !          1677:                        sprintf(dstname, "y:0x%04x", addr);
        !          1678:                } else {
        !          1679:                        sprintf(dstname, "x:0x%04x", addr);
        !          1680:                }
        !          1681:        } else {
        !          1682:                /* Read pp */
        !          1683: 
        !          1684:                if (memspace) {
        !          1685:                        sprintf(srcname, "y:0x%04x", addr);
        !          1686:                } else {
        !          1687:                        sprintf(srcname, "x:0x%04x", addr);
        !          1688:                }
        !          1689: 
        !          1690:                registers_changed[numreg]=1;
        !          1691:                strcpy(dstname, registers_name[numreg]);
        !          1692:        }
        !          1693: 
        !          1694:        fprintf(stderr,"Dsp: 0x%04x: movep %s,%s\n",dsp_pc, srcname, dstname);
        !          1695: }
        !          1696: 
        !          1697: static void dsp_movep_1(void)
        !          1698: {
        !          1699:        char srcname[16]="",dstname[16]="",name[16]="";
        !          1700:        uint32 addr, memspace; 
        !          1701: 
        !          1702:        /* p:ea,x:pp */
        !          1703:        /* x:pp,p:ea */
        !          1704:        /* p:ea,y:pp */
        !          1705:        /* y:pp,p:ea */
        !          1706: 
        !          1707:        addr = 0xffc0 + (cur_inst & BITMASK(6));
        !          1708:        dsp_calc_ea((cur_inst>>8) & BITMASK(6), name);
        !          1709:        memspace = (cur_inst>>16) & 1;
        !          1710: 
        !          1711:        if (cur_inst & (1<<15)) {
        !          1712:                /* Write pp */
        !          1713: 
        !          1714:                sprintf(srcname, "p:%s", name);
        !          1715: 
        !          1716:                if (memspace) {
        !          1717:                        sprintf(dstname, "y:0x%04x", addr);
        !          1718:                } else {
        !          1719:                        sprintf(dstname, "x:0x%04x", addr);
        !          1720:                }
        !          1721:        } else {
        !          1722:                /* Read pp */
        !          1723: 
        !          1724:                if (memspace) {
        !          1725:                        sprintf(srcname, "y:0x%04x", addr);
        !          1726:                } else {
        !          1727:                        sprintf(srcname, "x:0x%04x", addr);
        !          1728:                }
        !          1729: 
        !          1730:                sprintf(dstname, "p:%s", name);
        !          1731:        }
        !          1732: 
        !          1733:        fprintf(stderr,"Dsp: 0x%04x: movep %s,%s\n",dsp_pc, srcname, dstname);
        !          1734: }
        !          1735: 
        !          1736: static void dsp_movep_2(void)
        !          1737: {
        !          1738:        char srcname[16]="",dstname[16]="",name[16]="";
        !          1739:        uint32 addr, memspace, easpace, retour; 
        !          1740: 
        !          1741:        /* x:ea,x:pp */
        !          1742:        /* y:ea,x:pp */
        !          1743:        /* #xxxxxx,x:pp */
        !          1744:        /* x:pp,x:ea */
        !          1745:        /* x:pp,y:ea */
        !          1746: 
        !          1747:        /* x:ea,y:pp */
        !          1748:        /* y:ea,y:pp */
        !          1749:        /* #xxxxxx,y:pp */
        !          1750:        /* y:pp,y:ea */
        !          1751:        /* y:pp,x:ea */
        !          1752: 
        !          1753:        addr = 0xffc0 + (cur_inst & BITMASK(6));
        !          1754:        retour = dsp_calc_ea((cur_inst>>8) & BITMASK(6), name);
        !          1755:        memspace = (cur_inst>>16) & 1;
        !          1756:        easpace = (cur_inst>>6) & 1;
        !          1757: 
        !          1758:        if (cur_inst & (1<<15)) {
        !          1759:                /* Write pp */
        !          1760: 
        !          1761:                if (retour) {
        !          1762:                        sprintf(srcname, "#%s", name);
        !          1763:                } else {
        !          1764:                        if (easpace) {
        !          1765:                                sprintf(srcname, "y:%s", name);
        !          1766:                        } else {
        !          1767:                                sprintf(srcname, "x:%s", name);
        !          1768:                        }
        !          1769:                }
        !          1770: 
        !          1771:                if (memspace) {
        !          1772:                        sprintf(dstname, "y:0x%04x", addr);
        !          1773:                } else {
        !          1774:                        sprintf(dstname, "x:0x%04x", addr);
        !          1775:                }
        !          1776:        } else {
        !          1777:                /* Read pp */
        !          1778: 
        !          1779:                if (memspace) {
        !          1780:                        sprintf(srcname, "y:0x%04x", addr);
        !          1781:                } else {
        !          1782:                        sprintf(srcname, "x:0x%04x", addr);
        !          1783:                }
        !          1784: 
        !          1785:                if (easpace) {
        !          1786:                        sprintf(dstname, "y:%s", name);
        !          1787:                } else {
        !          1788:                        sprintf(dstname, "x:%s", name);
        !          1789:                }
        !          1790:        }
        !          1791: 
        !          1792:        fprintf(stderr,"Dsp: 0x%04x: movep %s,%s\n",dsp_pc, srcname, dstname);
        !          1793: }
        !          1794: 
        !          1795: static void dsp_nop(void)
        !          1796: {
        !          1797:        fprintf(stderr,"Dsp: 0x%04x: nop\n",dsp_pc);
        !          1798: }
        !          1799: 
        !          1800: static void dsp_norm(void)
        !          1801: {
        !          1802:        uint32 srcreg, destreg;
        !          1803: 
        !          1804:        srcreg = DSP_REG_R0+((cur_inst>>8) & BITMASK(3));
        !          1805:        destreg = DSP_REG_A+((cur_inst>>3) & 1);
        !          1806: 
        !          1807:        registers_changed[srcreg]=1;
        !          1808:        registers_changed[destreg]=1;
        !          1809: 
        !          1810:        fprintf(stderr,"Dsp: 0x%04x: norm %s,%s\n",dsp_pc, registers_name[srcreg], registers_name[destreg]);
        !          1811: }
        !          1812: 
        !          1813: static void dsp_ori(void)
        !          1814: {
        !          1815:        const char *regname;
        !          1816: 
        !          1817:        switch(cur_inst & BITMASK(2)) {
        !          1818:                case 0:
        !          1819:                        regname="mr";
        !          1820:                        registers_changed[DSP_REG_SR]=1;
        !          1821:                        break;
        !          1822:                case 1:
        !          1823:                        regname="ccr";
        !          1824:                        registers_changed[DSP_REG_SR]=1;
        !          1825:                        break;
        !          1826:                case 2:
        !          1827:                        regname="omr";
        !          1828:                        registers_changed[DSP_REG_OMR]=1;
        !          1829:                        break;
        !          1830:                default:
        !          1831:                        regname="";
        !          1832:                        break;
        !          1833:        }
        !          1834: 
        !          1835:        fprintf(stderr,"Dsp: 0x%04x: ori #0x%02x,%s\n",
        !          1836:                dsp_pc,
        !          1837:                (cur_inst>>8) & BITMASK(8),
        !          1838:                regname
        !          1839:        );
        !          1840: }
        !          1841: 
        !          1842: static void dsp_rep(void)
        !          1843: {
        !          1844:        uint32 value;
        !          1845: 
        !          1846:        value = (cur_inst>>12) & (BITMASK(2)<<2);
        !          1847:        value |= (cur_inst>>6) & (1<<1);
        !          1848:        value |= (cur_inst>>5) & 1;
        !          1849: 
        !          1850:        opcodes_rep[value]();
        !          1851: 
        !          1852:        registers_changed[DSP_REG_LA]=1;
        !          1853:        registers_changed[DSP_REG_LC]=1;
        !          1854: }
        !          1855: 
        !          1856: static void dsp_rep_1(void)
        !          1857: {
        !          1858:        char name[16];
        !          1859: 
        !          1860:        /* x:aa */
        !          1861:        /* y:aa */
        !          1862: 
        !          1863:        if (cur_inst & (1<<6)) {
        !          1864:                sprintf(name, "y:0x%04x",(cur_inst>>8) & BITMASK(6));
        !          1865:        } else {
        !          1866:                sprintf(name, "x:0x%04x",(cur_inst>>8) & BITMASK(6));
        !          1867:        }
        !          1868: 
        !          1869:        fprintf(stderr,"Dsp: 0x%04x: rep %s\n",dsp_pc, name);
        !          1870: }
        !          1871: 
        !          1872: static void dsp_rep_3(void)
        !          1873: {
        !          1874:        /* #xxx */
        !          1875:        fprintf(stderr,"Dsp: 0x%04x: rep #0x%02x\n",dsp_pc, (cur_inst>>8) & BITMASK(8));
        !          1876: }
        !          1877: 
        !          1878: static void dsp_rep_5(void)
        !          1879: {
        !          1880:        char name[16],addr_name[16];
        !          1881: 
        !          1882:        /* x:ea */
        !          1883:        /* y:ea */
        !          1884: 
        !          1885:        dsp_calc_ea((cur_inst>>8) & BITMASK(6), addr_name);
        !          1886:        if (cur_inst & (1<<6)) {
        !          1887:                sprintf(name, "y:%s",addr_name);
        !          1888:        } else {
        !          1889:                sprintf(name, "x:%s",addr_name);
        !          1890:        }
        !          1891: 
        !          1892:        fprintf(stderr,"Dsp: 0x%04x: rep %s\n",dsp_pc, name);
        !          1893: }
        !          1894: 
        !          1895: static void dsp_rep_d(void)
        !          1896: {
        !          1897:        /* R */
        !          1898: 
        !          1899:        fprintf(stderr,"Dsp: 0x%04x: rep %s\n",dsp_pc, registers_name[(cur_inst>>8) & BITMASK(6)]);
        !          1900: }
        !          1901: 
        !          1902: static void dsp_reset(void)
        !          1903: {
        !          1904:        fprintf(stderr,"Dsp: 0x%04x: reset\n",dsp_pc);
        !          1905: }
        !          1906: 
        !          1907: static void dsp_rti(void)
        !          1908: {
        !          1909:        fprintf(stderr,"Dsp: 0x%04x: rti\n",dsp_pc);
        !          1910: }
        !          1911: 
        !          1912: static void dsp_rts(void)
        !          1913: {
        !          1914:        fprintf(stderr,"Dsp: 0x%04x: rts\n",dsp_pc);
        !          1915: }
        !          1916: 
        !          1917: static void dsp_stop(void)
        !          1918: {
        !          1919:        fprintf(stderr,"Dsp: 0x%04x: stop\n",dsp_pc);
        !          1920: }
        !          1921:        
        !          1922: static void dsp_swi(void)
        !          1923: {
        !          1924:        fprintf(stderr,"Dsp: 0x%04x: swi\n",dsp_pc);
        !          1925: }
        !          1926: 
        !          1927: static void dsp_tcc(void)
        !          1928: {
        !          1929:        char ccname[16];
        !          1930:        uint32 src1reg, dst1reg, src2reg, dst2reg;
        !          1931: 
        !          1932:        dsp_calc_cc((cur_inst>>12) & BITMASK(4), ccname);
        !          1933:        src1reg = registers_tcc[(cur_inst>>3) & BITMASK(4)][0];
        !          1934:        dst1reg = registers_tcc[(cur_inst>>3) & BITMASK(4)][0];
        !          1935: 
        !          1936:        registers_changed[dst1reg]=1;
        !          1937:        if (cur_inst & (1<<16)) {
        !          1938:                src2reg = DSP_REG_R0+(cur_inst & BITMASK(3));
        !          1939:                dst2reg = DSP_REG_R0+((cur_inst>>8) & BITMASK(3));
        !          1940: 
        !          1941:                registers_changed[dst2reg]=1;
        !          1942:                fprintf(stderr,"Dsp: 0x%04x: t%s %s,%s %s,%s\n",
        !          1943:                        dsp_pc,
        !          1944:                        ccname,
        !          1945:                        registers_name[src1reg],
        !          1946:                        registers_name[dst1reg],
        !          1947:                        registers_name[src2reg],
        !          1948:                        registers_name[dst2reg]
        !          1949:                );
        !          1950:        } else {
        !          1951:                fprintf(stderr,"Dsp: 0x%04x: t%s %s,%s\n",
        !          1952:                        dsp_pc,
        !          1953:                        ccname,
        !          1954:                        registers_name[src1reg],
        !          1955:                        registers_name[dst1reg]
        !          1956:                );
        !          1957:        }
        !          1958: }
        !          1959: 
        !          1960: static void dsp_wait(void)
        !          1961: {
        !          1962:        fprintf(stderr,"Dsp: 0x%04x: wait\n",dsp_pc);
        !          1963: }
        !          1964: 
        !          1965: /**********************************
        !          1966:  *     Parallel moves
        !          1967:  **********************************/
        !          1968: 
        !          1969: static void dsp_pm(void)
        !          1970: {
        !          1971:        uint32 value;
        !          1972: 
        !          1973:        value = (cur_inst >> 20) & BITMASK(4);
        !          1974: 
        !          1975:        opcodes_parmove[value]();
        !          1976: }
        !          1977: 
        !          1978: static void dsp_pm_0(void)
        !          1979: {
        !          1980:        char space_name[16], addr_name[16];
        !          1981:        uint32 memspace, numreg1, numreg2;
        !          1982: /*
        !          1983:        0000 100d 00mm mrrr S,x:ea      x0,D
        !          1984:        0000 100d 10mm mrrr S,y:ea      y0,D
        !          1985: */
        !          1986:        memspace = (cur_inst>>15) & 1;
        !          1987:        numreg1 = DSP_REG_A+((cur_inst>>16) & 1);
        !          1988:        dsp_calc_ea((cur_inst>>8) & BITMASK(6), addr_name);
        !          1989: 
        !          1990:        if (memspace) {
        !          1991:                strcpy(space_name,"y");
        !          1992:                numreg2 = DSP_REG_Y0;
        !          1993:        } else {
        !          1994:                strcpy(space_name,"x");
        !          1995:                numreg2 = DSP_REG_X0;
        !          1996:        }
        !          1997: 
        !          1998:        registers_changed[numreg1]=1;
        !          1999: 
        !          2000:        sprintf(parallelmove_name,
        !          2001:                "%s,%s:%s %s,%s",
        !          2002:                registers_name[numreg1],
        !          2003:                space_name,
        !          2004:                addr_name,
        !          2005:                registers_name[numreg2],
        !          2006:                registers_name[numreg1]
        !          2007:        );
        !          2008: }
        !          2009: 
        !          2010: static void dsp_pm_1(void)
        !          2011: {
        !          2012: /*
        !          2013:        0001 ffdf w0mm mrrr x:ea,D1             S2,D2
        !          2014:                                                S1,x:ea         S2,D2
        !          2015:                                                #xxxxxx,D1      S2,D2
        !          2016:        0001 deff w1mm mrrr S1,D1               y:ea,D2
        !          2017:                                                S1,D1           S2,y:ea
        !          2018:                                                S1,D1           #xxxxxx,D2
        !          2019: */
        !          2020: 
        !          2021:        char addr_name[16];
        !          2022:        uint32 memspace, write_flag, retour, s1reg, s2reg, d1reg, d2reg;
        !          2023: 
        !          2024:        memspace = (cur_inst>>14) & 1;
        !          2025:        write_flag = (cur_inst>>15) & 1;
        !          2026:        retour = dsp_calc_ea((cur_inst>>8) & BITMASK(6), addr_name);
        !          2027: 
        !          2028:        if (memspace==DSP_SPACE_Y) {
        !          2029:                s2reg = d2reg = DSP_REG_Y0;
        !          2030:                switch((cur_inst>>16) & BITMASK(2)) {
        !          2031:                        case 0: s2reg = d2reg = DSP_REG_Y0;     break;
        !          2032:                        case 1: s2reg = d2reg = DSP_REG_Y1;     break;
        !          2033:                        case 2: s2reg = d2reg = DSP_REG_A;      break;
        !          2034:                        case 3: s2reg = d2reg = DSP_REG_B;      break;
        !          2035:                }
        !          2036: 
        !          2037:                s1reg = DSP_REG_A+((cur_inst>>19) & 1);
        !          2038:                d1reg = DSP_REG_X0+((cur_inst>>18) & 1);
        !          2039: 
        !          2040:                registers_changed[d1reg]=1;
        !          2041: 
        !          2042:                if (write_flag) {
        !          2043:                        /* Write D2 */
        !          2044: 
        !          2045:                        registers_changed[d2reg]=1;
        !          2046: 
        !          2047:                        if (retour) {
        !          2048:                                sprintf(parallelmove_name,"%s,%s #%s,%s",
        !          2049:                                        registers_name[s1reg],
        !          2050:                                        registers_name[d1reg],
        !          2051:                                        addr_name,
        !          2052:                                        registers_name[d2reg]
        !          2053:                                );
        !          2054:                        } else {
        !          2055:                                sprintf(parallelmove_name,"%s,%s y:%s,%s",
        !          2056:                                        registers_name[s1reg],
        !          2057:                                        registers_name[d1reg],
        !          2058:                                        addr_name,
        !          2059:                                        registers_name[d2reg]
        !          2060:                                );
        !          2061:                        }
        !          2062:                } else {
        !          2063:                        /* Read S2 */
        !          2064:                        sprintf(parallelmove_name,"%s,%s %s,y:%s",
        !          2065:                                registers_name[s1reg],
        !          2066:                                registers_name[d1reg],
        !          2067:                                registers_name[s2reg],
        !          2068:                                addr_name
        !          2069:                        );
        !          2070:                }               
        !          2071: 
        !          2072:        } else {
        !          2073:                s1reg = d1reg = DSP_REG_X0;
        !          2074:                switch((cur_inst>>18) & BITMASK(2)) {
        !          2075:                        case 0: s1reg = d1reg = DSP_REG_X0;     break;
        !          2076:                        case 1: s1reg = d1reg = DSP_REG_X1;     break;
        !          2077:                        case 2: s1reg = d1reg = DSP_REG_A;      break;
        !          2078:                        case 3: s1reg = d1reg = DSP_REG_B;      break;
        !          2079:                }
        !          2080: 
        !          2081:                s2reg = DSP_REG_A+((cur_inst>>17) & 1);
        !          2082:                d2reg = DSP_REG_Y0+((cur_inst>>16) & 1);
        !          2083: 
        !          2084:                registers_changed[d2reg]=1;
        !          2085: 
        !          2086:                if (write_flag) {
        !          2087:                        /* Write D1 */
        !          2088: 
        !          2089:                        registers_changed[d1reg]=1;
        !          2090: 
        !          2091:                        if (retour) {
        !          2092:                                sprintf(parallelmove_name,"#%s,%s %s,%s",
        !          2093:                                        addr_name,
        !          2094:                                        registers_name[d1reg],
        !          2095:                                        registers_name[s2reg],
        !          2096:                                        registers_name[d2reg]
        !          2097:                                );
        !          2098:                        } else {
        !          2099:                                sprintf(parallelmove_name,"x:%s,%s %s,%s",
        !          2100:                                        addr_name,
        !          2101:                                        registers_name[d1reg],
        !          2102:                                        registers_name[s2reg],
        !          2103:                                        registers_name[d2reg]
        !          2104:                                );
        !          2105:                        }
        !          2106:                } else {
        !          2107:                        /* Read S1 */
        !          2108:                        sprintf(parallelmove_name,"%s,x:%s %s,%s",
        !          2109:                                registers_name[s1reg],
        !          2110:                                addr_name,
        !          2111:                                registers_name[s2reg],
        !          2112:                                registers_name[d2reg]
        !          2113:                        );
        !          2114:                }               
        !          2115:        
        !          2116:        }
        !          2117: }
        !          2118: 
        !          2119: static void dsp_pm_2(void)
        !          2120: {
        !          2121:        char addr_name[16];
        !          2122:        uint32 numreg1, numreg2;
        !          2123: /*
        !          2124:        0010 0000 0000 0000 nop
        !          2125:        0010 0000 010m mrrr R update
        !          2126:        0010 00ee eeed dddd S,D
        !          2127:        001d dddd iiii iiii #xx,D
        !          2128: */
        !          2129:        if (((cur_inst >> 8) & 0xffff) == 0x2000) {
        !          2130:                return;
        !          2131:        }
        !          2132: 
        !          2133:        if (((cur_inst >> 8) & 0xffe0) == 0x2040) {
        !          2134:                dsp_calc_ea((cur_inst>>8) & BITMASK(5), addr_name);
        !          2135:                registers_changed[DSP_REG_R0+((cur_inst>>8) & BITMASK(3))]=1;
        !          2136:                sprintf(parallelmove_name, "%s,r%d",addr_name, (cur_inst>>8) & BITMASK(3));
        !          2137:                return;
        !          2138:        }
        !          2139: 
        !          2140:        if (((cur_inst >> 8) & 0xfc00) == 0x2000) {
        !          2141:                numreg1 = (cur_inst>>13) & BITMASK(5);
        !          2142:                numreg2 = (cur_inst>>8) & BITMASK(5);
        !          2143:                registers_changed[numreg2]=1;
        !          2144:                sprintf(parallelmove_name, "%s,%s", registers_name[numreg1], registers_name[numreg2]); 
        !          2145:                return;
        !          2146:        }
        !          2147: 
        !          2148:        numreg1 = (cur_inst>>16) & BITMASK(5);
        !          2149:        registers_changed[numreg1]=1;
        !          2150:        sprintf(parallelmove_name, "#0x%02x,%s", (cur_inst >> 8) & BITMASK(8), registers_name[numreg1]);
        !          2151: }
        !          2152: 
        !          2153: static void dsp_pm_4(void)
        !          2154: {
        !          2155:        char addr_name[16];
        !          2156:        uint32 value, retour, ea_mode, memspace;
        !          2157: /*
        !          2158:        0100 l0ll w0aa aaaa l:aa,D
        !          2159:                                                S,l:aa
        !          2160:        0100 l0ll w1mm mrrr l:ea,D
        !          2161:                                                S,l:ea
        !          2162:        01dd 0ddd w0aa aaaa x:aa,D
        !          2163:                                                S,x:aa
        !          2164:        01dd 0ddd w1mm mrrr x:ea,D
        !          2165:                                                S,x:ea
        !          2166:                                                #xxxxxx,D
        !          2167:        01dd 1ddd w0aa aaaa y:aa,D
        !          2168:                                                S,y:aa
        !          2169:        01dd 1ddd w1mm mrrr y:ea,D
        !          2170:                                                S,y:ea
        !          2171:                                                #xxxxxx,D
        !          2172: */
        !          2173:        value = (cur_inst>>16) & BITMASK(3);
        !          2174:        value |= (cur_inst>>17) & (BITMASK(2)<<3);
        !          2175: 
        !          2176:        ea_mode = (cur_inst>>8) & BITMASK(6);
        !          2177: 
        !          2178:        if ((value>>2)==0) {
        !          2179:                /* L: memory move */
        !          2180:                if (cur_inst & (1<<14)) {
        !          2181:                        retour = dsp_calc_ea(ea_mode, addr_name);       
        !          2182:                } else {
        !          2183:                        sprintf(addr_name,"0x%04x", value);
        !          2184:                        retour = 0;
        !          2185:                }
        !          2186: 
        !          2187:                value = (cur_inst>>16) & BITMASK(2);
        !          2188:                value |= (cur_inst>>17) & (1<<2);
        !          2189: 
        !          2190:                if (cur_inst & (1<<15)) {
        !          2191:                        /* Write D */
        !          2192: 
        !          2193:                        registers_changed[value]=1;
        !          2194:                        if (retour) {
        !          2195:                                sprintf(parallelmove_name, "#%s,%s", addr_name, registers_lmove[value]);
        !          2196:                        } else {
        !          2197:                                sprintf(parallelmove_name, "l:%s,%s", addr_name, registers_lmove[value]);
        !          2198:                        }
        !          2199:                } else {
        !          2200:                        /* Read S */
        !          2201:                        sprintf(parallelmove_name, "%s,l:%s", registers_lmove[value], addr_name);
        !          2202:                }
        !          2203: 
        !          2204:                return;
        !          2205:        }
        !          2206: 
        !          2207:        memspace = (cur_inst>>19) & 1;
        !          2208:        if (cur_inst & (1<<14)) {
        !          2209:                retour = dsp_calc_ea(ea_mode, addr_name);       
        !          2210:        } else {
        !          2211:                sprintf(addr_name,"0x%04x", ea_mode);
        !          2212:                retour = 0;
        !          2213:        }
        !          2214: 
        !          2215:        if (memspace) {
        !          2216:                /* Y: */
        !          2217: 
        !          2218:                if (cur_inst & (1<<15)) {
        !          2219:                        /* Write D */
        !          2220: 
        !          2221:                        registers_changed[value]=1;
        !          2222:                        if (retour) {
        !          2223:                                sprintf(parallelmove_name, "#%s,%s", addr_name, registers_name[value]);
        !          2224:                        } else {
        !          2225:                                sprintf(parallelmove_name, "y:%s,%s", addr_name, registers_name[value]);
        !          2226:                        }
        !          2227: 
        !          2228:                } else {
        !          2229:                        /* Read S */
        !          2230:                        sprintf(parallelmove_name, "%s,y:%s", registers_name[value], addr_name);
        !          2231:                }
        !          2232:        } else {
        !          2233:                /* X: */
        !          2234: 
        !          2235:                if (cur_inst & (1<<15)) {
        !          2236:                        /* Write D */
        !          2237: 
        !          2238:                        registers_changed[value]=1;
        !          2239: 
        !          2240:                        if (retour) {
        !          2241:                                sprintf(parallelmove_name, "#%s,%s", addr_name, registers_name[value]);
        !          2242:                        } else {
        !          2243:                                sprintf(parallelmove_name, "x:%s,%s", addr_name, registers_name[value]);
        !          2244:                        }
        !          2245:                } else {
        !          2246:                        /* Read S */
        !          2247:                        sprintf(parallelmove_name, "%s,x:%s", registers_name[value], addr_name);
        !          2248:                }
        !          2249:        }
        !          2250: }
        !          2251: 
        !          2252: static void dsp_pm_8(void)
        !          2253: {
        !          2254:        char addr1_name[16], addr2_name[16];
        !          2255:        uint32 ea_mode1, ea_mode2, numreg1, numreg2;
        !          2256: /*
        !          2257:        1wmm eeff WrrM MRRR x:ea,D1             y:ea,D2 
        !          2258:                                                x:ea,D1         S2,y:ea
        !          2259:                                                S1,x:ea         y:ea,D2
        !          2260:                                                S1,x:ea         S2,y:ea
        !          2261: */
        !          2262:        numreg1 = DSP_REG_X0;
        !          2263:        switch((cur_inst>>18) & BITMASK(2)) {
        !          2264:                case 0: numreg1 = DSP_REG_X0;   break;
        !          2265:                case 1: numreg1 = DSP_REG_X1;   break;
        !          2266:                case 2: numreg1 = DSP_REG_A;    break;
        !          2267:                case 3: numreg1 = DSP_REG_B;    break;
        !          2268:        }
        !          2269: 
        !          2270:        numreg2 = DSP_REG_Y0;
        !          2271:        switch((cur_inst>>16) & BITMASK(2)) {
        !          2272:                case 0: numreg2 = DSP_REG_Y0;   break;
        !          2273:                case 1: numreg2 = DSP_REG_Y1;   break;
        !          2274:                case 2: numreg2 = DSP_REG_A;    break;
        !          2275:                case 3: numreg2 = DSP_REG_B;    break;
        !          2276:        }
        !          2277: 
        !          2278:        ea_mode1 = (cur_inst>>8) & BITMASK(5);
        !          2279:        if ((ea_mode1>>3) == 0) {
        !          2280:                ea_mode1 |= (1<<5);
        !          2281:        }
        !          2282:        ea_mode2 = (cur_inst>>13) & BITMASK(2);
        !          2283:        ea_mode2 |= ((cur_inst>>20) & BITMASK(2))<<3;
        !          2284:        if ((ea_mode1 & (1<<2))==0) {
        !          2285:                ea_mode2 |= 1<<2;
        !          2286:        }
        !          2287:        if ((ea_mode2>>3) == 0) {
        !          2288:                ea_mode2 |= (1<<5);
        !          2289:        }
        !          2290: 
        !          2291:        dsp_calc_ea(ea_mode1, addr1_name);
        !          2292:        dsp_calc_ea(ea_mode2, addr2_name);
        !          2293:        
        !          2294:        if (cur_inst & (1<<15)) {
        !          2295:                registers_changed[numreg1]=1;
        !          2296:                if (cur_inst & (1<<22)) {
        !          2297:                        registers_changed[numreg2]=1;
        !          2298:                        sprintf(parallelmove_name, "x:%s,%s y:%s,%s",
        !          2299:                                addr1_name,
        !          2300:                                registers_name[numreg1],
        !          2301:                                addr2_name,
        !          2302:                                registers_name[numreg2]
        !          2303:                        );
        !          2304:                } else {
        !          2305:                        sprintf(parallelmove_name, "x:%s,%s %s,y:%s",
        !          2306:                                addr1_name,
        !          2307:                                registers_name[numreg1],
        !          2308:                                registers_name[numreg2],
        !          2309:                                addr2_name
        !          2310:                        );
        !          2311:                }
        !          2312:        } else {
        !          2313:                if (cur_inst & (1<<22)) {
        !          2314:                        registers_changed[numreg2]=1;
        !          2315:                        sprintf(parallelmove_name, "%s,x:%s y:%s,%s",
        !          2316:                                registers_name[numreg1],
        !          2317:                                addr1_name,
        !          2318:                                addr2_name,
        !          2319:                                registers_name[numreg2]
        !          2320:                        );
        !          2321:                } else {
        !          2322:                        sprintf(parallelmove_name, "%s,x:%s %s,y:%s",
        !          2323:                                registers_name[numreg1],
        !          2324:                                addr1_name,
        !          2325:                                registers_name[numreg2],
        !          2326:                                addr2_name
        !          2327:                        );
        !          2328:                }
        !          2329:        }       
        !          2330: }
        !          2331: 
        !          2332: 
        !          2333: /**********************************
        !          2334:  *     Parallel moves ALU instructions
        !          2335:  **********************************/
        !          2336: 
        !          2337: static void dsp_abs(void)
        !          2338: {
        !          2339:        uint32 numreg;
        !          2340:        
        !          2341:        numreg = DSP_REG_A+((cur_inst>>3) & 1);
        !          2342: 
        !          2343:        registers_changed[numreg]=1;
        !          2344:        fprintf(stderr,"Dsp: 0x%04x: abs %s %s\n",
        !          2345:                dsp_pc,
        !          2346:                registers_name[numreg],
        !          2347:                parallelmove_name
        !          2348:        );
        !          2349: }
        !          2350: 
        !          2351: static void dsp_adc(void)
        !          2352: {
        !          2353:        const char *srcname;
        !          2354:        uint32 numreg;
        !          2355: 
        !          2356:        if (cur_inst & (1<<4)) {
        !          2357:                srcname="y";
        !          2358:        } else {
        !          2359:                srcname="x";
        !          2360:        }
        !          2361: 
        !          2362:        numreg=DSP_REG_A+((cur_inst>>3) & 1);
        !          2363:        registers_changed[numreg]=1;
        !          2364: 
        !          2365:        fprintf(stderr,"Dsp: 0x%04x: adc %s,%s %s\n",
        !          2366:                dsp_pc,
        !          2367:                srcname,
        !          2368:                registers_name[numreg],
        !          2369:                parallelmove_name
        !          2370:        );
        !          2371: }
        !          2372: 
        !          2373: static void dsp_add(void)
        !          2374: {
        !          2375:        const char *srcname;
        !          2376:        uint32 srcreg, dstreg;
        !          2377:        
        !          2378:        srcreg = (cur_inst>>4) & BITMASK(3);
        !          2379:        dstreg = (cur_inst>>3) & 1;
        !          2380: 
        !          2381:        switch(srcreg) {
        !          2382:                case 1:
        !          2383:                        srcreg = dstreg ^ 1;
        !          2384:                        srcname = registers_name[DSP_REG_A+srcreg];
        !          2385:                        break;
        !          2386:                case 2:
        !          2387:                        srcname="x";
        !          2388:                        break;
        !          2389:                case 3:
        !          2390:                        srcname="y";
        !          2391:                        break;
        !          2392:                case DSP_REG_X0:
        !          2393:                case DSP_REG_X1:
        !          2394:                case DSP_REG_Y0:
        !          2395:                case DSP_REG_Y1:
        !          2396:                        srcname=registers_name[srcreg];
        !          2397:                        break;
        !          2398:                default:
        !          2399:                        srcname="";
        !          2400:                        break;
        !          2401:        }
        !          2402: 
        !          2403:        registers_changed[DSP_REG_A+dstreg]=1;
        !          2404:        fprintf(stderr,"Dsp: 0x%04x: add %s,%s %s\n",
        !          2405:                dsp_pc,
        !          2406:                srcname,
        !          2407:                registers_name[DSP_REG_A+dstreg],
        !          2408:                parallelmove_name
        !          2409:        );
        !          2410: }
        !          2411: 
        !          2412: static void dsp_addl(void)
        !          2413: {
        !          2414:        uint32 numreg;
        !          2415: 
        !          2416:        numreg = (cur_inst>>3) & 1;
        !          2417: 
        !          2418:        registers_changed[DSP_REG_A+numreg]=1;
        !          2419:        fprintf(stderr,"Dsp: 0x%04x: addl %s,%s %s\n",
        !          2420:                dsp_pc,
        !          2421:                registers_name[DSP_REG_A+(numreg ^ 1)],
        !          2422:                registers_name[DSP_REG_A+numreg],
        !          2423:                parallelmove_name
        !          2424:        );
        !          2425: }
        !          2426: 
        !          2427: static void dsp_addr(void)
        !          2428: {
        !          2429:        uint32 numreg;
        !          2430: 
        !          2431:        numreg = (cur_inst>>3) & 1;
        !          2432: 
        !          2433:        registers_changed[DSP_REG_A+numreg]=1;
        !          2434:        fprintf(stderr,"Dsp: 0x%04x: addr %s,%s %s\n",
        !          2435:                dsp_pc,
        !          2436:                registers_name[DSP_REG_A+(numreg ^ 1)],
        !          2437:                registers_name[DSP_REG_A+numreg],
        !          2438:                parallelmove_name
        !          2439:        );
        !          2440: }
        !          2441: 
        !          2442: static void dsp_and(void)
        !          2443: {
        !          2444:        uint32 numreg;
        !          2445: 
        !          2446:        numreg = DSP_REG_A+((cur_inst>>3) & 1);
        !          2447: 
        !          2448:        registers_changed[numreg]=1;
        !          2449: 
        !          2450:        fprintf(stderr,"Dsp: 0x%04x: and %s,%s %s\n",
        !          2451:                dsp_pc,
        !          2452:                registers_name[DSP_REG_X0+((cur_inst>>4) & BITMASK(2))],
        !          2453:                registers_name[numreg],
        !          2454:                parallelmove_name
        !          2455:        );
        !          2456: }
        !          2457: 
        !          2458: static void dsp_asl(void)
        !          2459: {
        !          2460:        uint32 numreg;
        !          2461: 
        !          2462:        numreg = DSP_REG_A+((cur_inst>>3) & 1);
        !          2463: 
        !          2464:        registers_changed[numreg]=1;
        !          2465: 
        !          2466:        fprintf(stderr,"Dsp: 0x%04x: asl %s %s\n",
        !          2467:                dsp_pc,
        !          2468:                registers_name[numreg],
        !          2469:                parallelmove_name
        !          2470:        );
        !          2471: }
        !          2472: 
        !          2473: static void dsp_asr(void)
        !          2474: {
        !          2475:        uint32 numreg;
        !          2476: 
        !          2477:        numreg = DSP_REG_A+((cur_inst>>3) & 1);
        !          2478: 
        !          2479:        registers_changed[numreg]=1;
        !          2480: 
        !          2481:        fprintf(stderr,"Dsp: 0x%04x: asr %s %s\n",
        !          2482:                dsp_pc,
        !          2483:                registers_name[numreg],
        !          2484:                parallelmove_name
        !          2485:        );
        !          2486: }
        !          2487: 
        !          2488: static void dsp_clr(void)
        !          2489: {
        !          2490:        uint32 numreg;
        !          2491: 
        !          2492:        numreg = DSP_REG_A+((cur_inst>>3) & 1);
        !          2493: 
        !          2494:        registers_changed[numreg]=1;
        !          2495: 
        !          2496:        fprintf(stderr,"Dsp: 0x%04x: clr %s %s\n",
        !          2497:                dsp_pc,
        !          2498:                registers_name[numreg],
        !          2499:                parallelmove_name
        !          2500:        );
        !          2501: }
        !          2502: 
        !          2503: static void dsp_cmp(void)
        !          2504: {
        !          2505:        uint32 srcreg, dstreg;
        !          2506:        
        !          2507:        srcreg = (cur_inst>>4) & BITMASK(3);
        !          2508:        dstreg = (cur_inst>>3) & 1;
        !          2509: 
        !          2510:        switch(srcreg) {
        !          2511:                case 0:
        !          2512:                        srcreg = DSP_REG_A+(dstreg ^ 1);
        !          2513:                        break;
        !          2514:                case 4:
        !          2515:                        srcreg = DSP_REG_X0;
        !          2516:                        break;
        !          2517:                case 5:
        !          2518:                        srcreg = DSP_REG_Y0;
        !          2519:                        break;
        !          2520:                case 6:
        !          2521:                        srcreg = DSP_REG_X1;
        !          2522:                        break;
        !          2523:                case 7:
        !          2524:                        srcreg = DSP_REG_Y1;
        !          2525:                        break;
        !          2526:        }
        !          2527: 
        !          2528:        fprintf(stderr,"Dsp: 0x%04x: cmp %s,%s %s\n",
        !          2529:                dsp_pc,
        !          2530:                registers_name[srcreg],
        !          2531:                registers_name[DSP_REG_A+dstreg],
        !          2532:                parallelmove_name
        !          2533:        );
        !          2534: }
        !          2535: 
        !          2536: static void dsp_cmpm(void)
        !          2537: {
        !          2538:        uint32 srcreg, dstreg;
        !          2539:        
        !          2540:        srcreg = (cur_inst>>4) & BITMASK(3);
        !          2541:        dstreg = (cur_inst>>3) & 1;
        !          2542: 
        !          2543:        switch(srcreg) {
        !          2544:                case 0:
        !          2545:                        srcreg = DSP_REG_A+(dstreg ^ 1);
        !          2546:                        break;
        !          2547:                case 4:
        !          2548:                        srcreg = DSP_REG_X0;
        !          2549:                        break;
        !          2550:                case 5:
        !          2551:                        srcreg = DSP_REG_Y0;
        !          2552:                        break;
        !          2553:                case 6:
        !          2554:                        srcreg = DSP_REG_X1;
        !          2555:                        break;
        !          2556:                case 7:
        !          2557:                        srcreg = DSP_REG_Y1;
        !          2558:                        break;
        !          2559:        }
        !          2560: 
        !          2561:        fprintf(stderr,"Dsp: 0x%04x: cmpm %s,%s %s\n",
        !          2562:                dsp_pc,
        !          2563:                registers_name[srcreg],
        !          2564:                registers_name[DSP_REG_A+dstreg],
        !          2565:                parallelmove_name
        !          2566:        );
        !          2567: }
        !          2568: 
        !          2569: static void dsp_eor(void)
        !          2570: {
        !          2571:        uint32 numreg;
        !          2572: 
        !          2573:        numreg = DSP_REG_A+((cur_inst>>3) & 1);
        !          2574: 
        !          2575:        registers_changed[numreg]=1;
        !          2576: 
        !          2577:        fprintf(stderr,"Dsp: 0x%04x: eor %s,%s %s\n",
        !          2578:                dsp_pc,
        !          2579:                registers_name[DSP_REG_X0+((cur_inst>>4) & BITMASK(2))],
        !          2580:                registers_name[numreg],
        !          2581:                parallelmove_name
        !          2582:        );
        !          2583: }
        !          2584: 
        !          2585: static void dsp_lsl(void)
        !          2586: {
        !          2587:        uint32 numreg;
        !          2588: 
        !          2589:        numreg = DSP_REG_A+((cur_inst>>3) & 1);
        !          2590: 
        !          2591:        registers_changed[numreg]=1;
        !          2592: 
        !          2593:        fprintf(stderr,"Dsp: 0x%04x: lsl %s %s\n",
        !          2594:                dsp_pc,
        !          2595:                registers_name[numreg],
        !          2596:                parallelmove_name
        !          2597:        );
        !          2598: }
        !          2599: 
        !          2600: static void dsp_lsr(void)
        !          2601: {
        !          2602:        uint32 numreg;
        !          2603: 
        !          2604:        numreg = DSP_REG_A+((cur_inst>>3) & 1);
        !          2605: 
        !          2606:        registers_changed[numreg]=1;
        !          2607: 
        !          2608:        fprintf(stderr,"Dsp: 0x%04x: lsr %s %s\n",
        !          2609:                dsp_pc,
        !          2610:                registers_name[numreg],
        !          2611:                parallelmove_name
        !          2612:        );
        !          2613: }
        !          2614: 
        !          2615: static void dsp_mac(void)
        !          2616: {
        !          2617:        const char *sign_name;
        !          2618:        uint32 src1reg=DSP_REG_NULL, src2reg=DSP_REG_NULL, dstreg;
        !          2619: 
        !          2620:        if (cur_inst & (1<<2)) {
        !          2621:                sign_name="-";
        !          2622:        } else {
        !          2623:                sign_name="";
        !          2624:        }
        !          2625:        
        !          2626:        switch((cur_inst>>4) & BITMASK(3)) {
        !          2627:                case 0:
        !          2628:                        src1reg = DSP_REG_X0;
        !          2629:                        src2reg = DSP_REG_X0;
        !          2630:                        break;
        !          2631:                case 1:
        !          2632:                        src1reg = DSP_REG_Y0;
        !          2633:                        src2reg = DSP_REG_Y0;
        !          2634:                        break;
        !          2635:                case 2:
        !          2636:                        src1reg = DSP_REG_X1;
        !          2637:                        src2reg = DSP_REG_X0;
        !          2638:                        break;
        !          2639:                case 3:
        !          2640:                        src1reg = DSP_REG_Y1;
        !          2641:                        src2reg = DSP_REG_Y0;
        !          2642:                        break;
        !          2643:                case 4:
        !          2644:                        src1reg = DSP_REG_X0;
        !          2645:                        src2reg = DSP_REG_Y1;
        !          2646:                        break;
        !          2647:                case 5:
        !          2648:                        src1reg = DSP_REG_Y0;
        !          2649:                        src2reg = DSP_REG_X0;
        !          2650:                        break;
        !          2651:                case 6:
        !          2652:                        src1reg = DSP_REG_X1;
        !          2653:                        src2reg = DSP_REG_Y0;
        !          2654:                        break;
        !          2655:                case 7:
        !          2656:                        src1reg = DSP_REG_Y1;
        !          2657:                        src2reg = DSP_REG_X1;
        !          2658:                        break;
        !          2659:        }
        !          2660:        dstreg = (cur_inst>>3) & 1;
        !          2661: 
        !          2662:        registers_changed[DSP_REG_A+dstreg]=1;
        !          2663:        fprintf(stderr,"Dsp: 0x%04x: mac %s%s,%s,%s %s\n",
        !          2664:                dsp_pc,
        !          2665:                sign_name,
        !          2666:                registers_name[src1reg],
        !          2667:                registers_name[src2reg],
        !          2668:                registers_name[DSP_REG_A+dstreg],
        !          2669:                parallelmove_name
        !          2670:        );
        !          2671: }
        !          2672: 
        !          2673: static void dsp_macr(void)
        !          2674: {
        !          2675:        const char *sign_name;
        !          2676:        uint32 src1reg=DSP_REG_NULL, src2reg=DSP_REG_NULL, dstreg;
        !          2677: 
        !          2678:        if (cur_inst & (1<<2)) {
        !          2679:                sign_name="-";
        !          2680:        } else {
        !          2681:                sign_name="";
        !          2682:        }
        !          2683:        
        !          2684:        switch((cur_inst>>4) & BITMASK(3)) {
        !          2685:                case 0:
        !          2686:                        src1reg = DSP_REG_X0;
        !          2687:                        src2reg = DSP_REG_X0;
        !          2688:                        break;
        !          2689:                case 1:
        !          2690:                        src1reg = DSP_REG_Y0;
        !          2691:                        src2reg = DSP_REG_Y0;
        !          2692:                        break;
        !          2693:                case 2:
        !          2694:                        src1reg = DSP_REG_X1;
        !          2695:                        src2reg = DSP_REG_X0;
        !          2696:                        break;
        !          2697:                case 3:
        !          2698:                        src1reg = DSP_REG_Y1;
        !          2699:                        src2reg = DSP_REG_Y0;
        !          2700:                        break;
        !          2701:                case 4:
        !          2702:                        src1reg = DSP_REG_X0;
        !          2703:                        src2reg = DSP_REG_Y1;
        !          2704:                        break;
        !          2705:                case 5:
        !          2706:                        src1reg = DSP_REG_Y0;
        !          2707:                        src2reg = DSP_REG_X0;
        !          2708:                        break;
        !          2709:                case 6:
        !          2710:                        src1reg = DSP_REG_X1;
        !          2711:                        src2reg = DSP_REG_Y0;
        !          2712:                        break;
        !          2713:                case 7:
        !          2714:                        src1reg = DSP_REG_Y1;
        !          2715:                        src2reg = DSP_REG_X1;
        !          2716:                        break;
        !          2717:        }
        !          2718:        dstreg = (cur_inst>>3) & 1;
        !          2719: 
        !          2720:        registers_changed[DSP_REG_A+dstreg]=1;
        !          2721:        fprintf(stderr,"Dsp: 0x%04x: macr %s%s,%s,%s %s\n",
        !          2722:                dsp_pc,
        !          2723:                sign_name,
        !          2724:                registers_name[src1reg],
        !          2725:                registers_name[src2reg],
        !          2726:                registers_name[DSP_REG_A+dstreg],
        !          2727:                parallelmove_name
        !          2728:        );
        !          2729: }
        !          2730: 
        !          2731: static void dsp_move(void)
        !          2732: {
        !          2733:        fprintf(stderr,"Dsp: 0x%04x: move %s\n",dsp_pc, parallelmove_name);
        !          2734: }
        !          2735: 
        !          2736: static void dsp_move_nopm(void)
        !          2737: {
        !          2738:        dsp_pm();
        !          2739:        fprintf(stderr,"Dsp: 0x%04x: move %s\n",dsp_pc, parallelmove_name);
        !          2740: }
        !          2741: 
        !          2742: static void dsp_mpy(void)
        !          2743: {
        !          2744:        const char *sign_name;
        !          2745:        uint32 src1reg=DSP_REG_NULL, src2reg=DSP_REG_NULL, dstreg;
        !          2746: 
        !          2747:        if (cur_inst & (1<<2)) {
        !          2748:                sign_name="-";
        !          2749:        } else {
        !          2750:                sign_name="";
        !          2751:        }
        !          2752:        
        !          2753:        switch((cur_inst>>4) & BITMASK(3)) {
        !          2754:                case 0:
        !          2755:                        src1reg = DSP_REG_X0;
        !          2756:                        src2reg = DSP_REG_X0;
        !          2757:                        break;
        !          2758:                case 1:
        !          2759:                        src1reg = DSP_REG_Y0;
        !          2760:                        src2reg = DSP_REG_Y0;
        !          2761:                        break;
        !          2762:                case 2:
        !          2763:                        src1reg = DSP_REG_X1;
        !          2764:                        src2reg = DSP_REG_X0;
        !          2765:                        break;
        !          2766:                case 3:
        !          2767:                        src1reg = DSP_REG_Y1;
        !          2768:                        src2reg = DSP_REG_Y0;
        !          2769:                        break;
        !          2770:                case 4:
        !          2771:                        src1reg = DSP_REG_X0;
        !          2772:                        src2reg = DSP_REG_Y1;
        !          2773:                        break;
        !          2774:                case 5:
        !          2775:                        src1reg = DSP_REG_Y0;
        !          2776:                        src2reg = DSP_REG_X0;
        !          2777:                        break;
        !          2778:                case 6:
        !          2779:                        src1reg = DSP_REG_X1;
        !          2780:                        src2reg = DSP_REG_Y0;
        !          2781:                        break;
        !          2782:                case 7:
        !          2783:                        src1reg = DSP_REG_Y1;
        !          2784:                        src2reg = DSP_REG_X1;
        !          2785:                        break;
        !          2786:        }
        !          2787:        dstreg = (cur_inst>>3) & 1;
        !          2788: 
        !          2789:        registers_changed[DSP_REG_A+dstreg]=1;
        !          2790:        fprintf(stderr,"Dsp: 0x%04x: mpy %s%s,%s,%s %s\n",
        !          2791:                dsp_pc,
        !          2792:                sign_name,
        !          2793:                registers_name[src1reg],
        !          2794:                registers_name[src2reg],
        !          2795:                registers_name[DSP_REG_A+dstreg],
        !          2796:                parallelmove_name
        !          2797:        );
        !          2798: }
        !          2799: 
        !          2800: static void dsp_mpyr(void)
        !          2801: {
        !          2802:        const char *sign_name;
        !          2803:        uint32 src1reg=DSP_REG_NULL, src2reg=DSP_REG_NULL, dstreg;
        !          2804: 
        !          2805:        if (cur_inst & (1<<2)) {
        !          2806:                sign_name="-";
        !          2807:        } else {
        !          2808:                sign_name="";
        !          2809:        }
        !          2810:        
        !          2811:        switch((cur_inst>>4) & BITMASK(3)) {
        !          2812:                case 0:
        !          2813:                        src1reg = DSP_REG_X0;
        !          2814:                        src2reg = DSP_REG_X0;
        !          2815:                        break;
        !          2816:                case 1:
        !          2817:                        src1reg = DSP_REG_Y0;
        !          2818:                        src2reg = DSP_REG_Y0;
        !          2819:                        break;
        !          2820:                case 2:
        !          2821:                        src1reg = DSP_REG_X1;
        !          2822:                        src2reg = DSP_REG_X0;
        !          2823:                        break;
        !          2824:                case 3:
        !          2825:                        src1reg = DSP_REG_Y1;
        !          2826:                        src2reg = DSP_REG_Y0;
        !          2827:                        break;
        !          2828:                case 4:
        !          2829:                        src1reg = DSP_REG_X0;
        !          2830:                        src2reg = DSP_REG_Y1;
        !          2831:                        break;
        !          2832:                case 5:
        !          2833:                        src1reg = DSP_REG_Y0;
        !          2834:                        src2reg = DSP_REG_X0;
        !          2835:                        break;
        !          2836:                case 6:
        !          2837:                        src1reg = DSP_REG_X1;
        !          2838:                        src2reg = DSP_REG_Y0;
        !          2839:                        break;
        !          2840:                case 7:
        !          2841:                        src1reg = DSP_REG_Y1;
        !          2842:                        src2reg = DSP_REG_X1;
        !          2843:                        break;
        !          2844:        }
        !          2845:        dstreg = (cur_inst>>3) & 1;
        !          2846: 
        !          2847:        registers_changed[DSP_REG_A+dstreg]=1;
        !          2848:        fprintf(stderr,"Dsp: 0x%04x: mpyr %s%s,%s,%s %s\n",
        !          2849:                dsp_pc,
        !          2850:                sign_name,
        !          2851:                registers_name[src1reg],
        !          2852:                registers_name[src2reg],
        !          2853:                registers_name[DSP_REG_A+dstreg],
        !          2854:                parallelmove_name
        !          2855:        );
        !          2856: }
        !          2857: 
        !          2858: static void dsp_neg(void)
        !          2859: {
        !          2860:        uint32 numreg;
        !          2861: 
        !          2862:        numreg = DSP_REG_A+((cur_inst>>3) & 1);
        !          2863: 
        !          2864:        registers_changed[numreg]=1;
        !          2865: 
        !          2866:        fprintf(stderr,"Dsp: 0x%04x: neg %s %s\n",
        !          2867:                dsp_pc,
        !          2868:                registers_name[numreg],
        !          2869:                parallelmove_name
        !          2870:        );
        !          2871: }
        !          2872: 
        !          2873: static void dsp_not(void)
        !          2874: {
        !          2875:        uint32 numreg;
        !          2876: 
        !          2877:        numreg = DSP_REG_A+((cur_inst>>3) & 1);
        !          2878: 
        !          2879:        registers_changed[numreg]=1;
        !          2880: 
        !          2881:        fprintf(stderr,"Dsp: 0x%04x: not %s %s\n",
        !          2882:                dsp_pc,
        !          2883:                registers_name[numreg],
        !          2884:                parallelmove_name
        !          2885:        );
        !          2886: }
        !          2887: 
        !          2888: static void dsp_or(void)
        !          2889: {
        !          2890:        uint32 numreg;
        !          2891: 
        !          2892:        numreg = DSP_REG_A+((cur_inst>>3) & 1);
        !          2893: 
        !          2894:        registers_changed[numreg]=1;
        !          2895: 
        !          2896:        fprintf(stderr,"Dsp: 0x%04x: or %s,%s %s\n",
        !          2897:                dsp_pc,
        !          2898:                registers_name[DSP_REG_X0+((cur_inst>>4) & BITMASK(2))],
        !          2899:                registers_name[numreg],
        !          2900:                parallelmove_name
        !          2901:        );
        !          2902: }
        !          2903: 
        !          2904: static void dsp_rnd(void)
        !          2905: {
        !          2906:        uint32 numreg;
        !          2907: 
        !          2908:        numreg = DSP_REG_A+((cur_inst>>3) & 1);
        !          2909: 
        !          2910:        registers_changed[numreg]=1;
        !          2911: 
        !          2912:        fprintf(stderr,"Dsp: 0x%04x: rnd %s %s\n",
        !          2913:                dsp_pc,
        !          2914:                registers_name[numreg],
        !          2915:                parallelmove_name
        !          2916:        );
        !          2917: }
        !          2918: 
        !          2919: static void dsp_rol(void)
        !          2920: {
        !          2921:        uint32 numreg;
        !          2922: 
        !          2923:        numreg = DSP_REG_A+((cur_inst>>3) & 1);
        !          2924: 
        !          2925:        registers_changed[numreg]=1;
        !          2926: 
        !          2927:        fprintf(stderr,"Dsp: 0x%04x: rol %s %s\n",
        !          2928:                dsp_pc,
        !          2929:                registers_name[numreg],
        !          2930:                parallelmove_name
        !          2931:        );
        !          2932: }
        !          2933: 
        !          2934: static void dsp_ror(void)
        !          2935: {
        !          2936:        uint32 numreg;
        !          2937: 
        !          2938:        numreg = DSP_REG_A+((cur_inst>>3) & 1);
        !          2939: 
        !          2940:        registers_changed[numreg]=1;
        !          2941: 
        !          2942:        fprintf(stderr,"Dsp: 0x%04x: ror %s %s\n",
        !          2943:                dsp_pc,
        !          2944:                registers_name[numreg],
        !          2945:                parallelmove_name
        !          2946:        );
        !          2947: }
        !          2948: 
        !          2949: static void dsp_sbc(void)
        !          2950: {
        !          2951:        const char *srcname;
        !          2952:        uint32 numreg;
        !          2953: 
        !          2954:        if (cur_inst & (1<<4)) {
        !          2955:                srcname="y";
        !          2956:        } else {
        !          2957:                srcname="x";
        !          2958:        }
        !          2959: 
        !          2960:        numreg = DSP_REG_A+((cur_inst>>3) & 1);
        !          2961: 
        !          2962:        registers_changed[numreg]=1;
        !          2963: 
        !          2964:        fprintf(stderr,"Dsp: 0x%04x: sbc %s,%s %s\n",
        !          2965:                dsp_pc,
        !          2966:                srcname,
        !          2967:                registers_name[numreg],
        !          2968:                parallelmove_name
        !          2969:        );
        !          2970: }
        !          2971: 
        !          2972: static void dsp_sub(void)
        !          2973: {
        !          2974:        const char *srcname;
        !          2975:        uint32 srcreg, dstreg;
        !          2976:        
        !          2977:        srcreg = (cur_inst>>4) & BITMASK(3);
        !          2978:        dstreg = (cur_inst>>3) & 1;
        !          2979: 
        !          2980:        switch(srcreg) {
        !          2981:                case 1:
        !          2982:                        srcreg = dstreg ^ 1;
        !          2983:                        srcname = registers_name[DSP_REG_A+srcreg];
        !          2984:                        break;
        !          2985:                case 2:
        !          2986:                        srcname="x";
        !          2987:                        break;
        !          2988:                case 3:
        !          2989:                        srcname="y";
        !          2990:                        break;
        !          2991:                case DSP_REG_X0:
        !          2992:                case DSP_REG_X1:
        !          2993:                case DSP_REG_Y0:
        !          2994:                case DSP_REG_Y1:
        !          2995:                        srcname=registers_name[srcreg];
        !          2996:                        break;
        !          2997:                default:
        !          2998:                        srcname="";
        !          2999:                        break;
        !          3000:        }
        !          3001: 
        !          3002:        registers_changed[DSP_REG_A+dstreg]=1;
        !          3003:        fprintf(stderr,"Dsp: 0x%04x: sub %s,%s %s\n",
        !          3004:                dsp_pc,
        !          3005:                srcname,
        !          3006:                registers_name[DSP_REG_A+dstreg],
        !          3007:                parallelmove_name
        !          3008:        );
        !          3009: }
        !          3010: 
        !          3011: static void dsp_subl(void)
        !          3012: {
        !          3013:        uint32 numreg;
        !          3014: 
        !          3015:        numreg = (cur_inst>>3) & 1;
        !          3016: 
        !          3017:        registers_changed[DSP_REG_A+numreg]=1;
        !          3018:        fprintf(stderr,"Dsp: 0x%04x: subl %s,%s %s\n",
        !          3019:                dsp_pc,
        !          3020:                registers_name[DSP_REG_A+(numreg ^ 1)],
        !          3021:                registers_name[DSP_REG_A+numreg],
        !          3022:                parallelmove_name
        !          3023:        );
        !          3024: }
        !          3025: 
        !          3026: static void dsp_subr(void)
        !          3027: {
        !          3028:        uint32 numreg;
        !          3029: 
        !          3030:        numreg = (cur_inst>>3) & 1;
        !          3031: 
        !          3032:        registers_changed[DSP_REG_A+numreg]=1;
        !          3033:        fprintf(stderr,"Dsp: 0x%04x: subr %s,%s %s\n",
        !          3034:                dsp_pc,
        !          3035:                registers_name[DSP_REG_A+(numreg ^ 1)],
        !          3036:                registers_name[DSP_REG_A+numreg],
        !          3037:                parallelmove_name
        !          3038:        );
        !          3039: }
        !          3040: 
        !          3041: static void dsp_tfr(void)
        !          3042: {
        !          3043:        uint32 srcreg, dstreg;
        !          3044:        
        !          3045:        srcreg = (cur_inst>>4) & BITMASK(3);
        !          3046:        dstreg = (cur_inst>>3) & 1;
        !          3047: 
        !          3048:        if (srcreg==0) {
        !          3049:                srcreg = DSP_REG_A+(dstreg ^ 1);
        !          3050:        }
        !          3051: 
        !          3052:        registers_changed[DSP_REG_A+dstreg]=1;
        !          3053:        fprintf(stderr,"Dsp: 0x%04x: tfr %s,%s %s\n",
        !          3054:                dsp_pc,
        !          3055:                registers_name[srcreg],
        !          3056:                registers_name[DSP_REG_A+dstreg],
        !          3057:                parallelmove_name
        !          3058:        );
        !          3059: }
        !          3060: 
        !          3061: static void dsp_tst(void)
        !          3062: {
        !          3063:        fprintf(stderr,"Dsp: 0x%04x: tst %s %s\n",
        !          3064:                dsp_pc,
        !          3065:                registers_name[DSP_REG_A+((cur_inst>>3) & 1)],
        !          3066:                parallelmove_name
        !          3067:        );
        !          3068: }
        !          3069: 
        !          3070: /*
        !          3071:        2002-07-31:PM
        !          3072:                BUG:pm_2 (register update) wrong calc of eamode
        !          3073:        2002-07-30:PM
        !          3074:                FIX:output registers that have been written to
        !          3075:        2002-07-26:PM
        !          3076:                BUG:added missing '\n' to disasm output
        !          3077:        2002-07-22:PM
        !          3078:                FIX:disasm output changed from D(bug()) to fprintf()
        !          3079:        2002-07-19:PM
        !          3080:                BUG:movec_b and movec_d operations permuted
        !          3081:                BUG:pm_5: bad calc of address in [x|y]:aa addressing
        !          3082: */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.