OpenCores
URL https://opencores.org/ocsvn/zipcpu/zipcpu/trunk

Subversion Repositories zipcpu

[/] [zipcpu/] [trunk/] [sw/] [zasm/] [zopcodes.cpp] - Diff between revs 188 and 202

Show entire file | Details | Blame | View Log

Rev 188 Rev 202
Line 4... Line 4...
//
//
// Project:     Zip CPU -- a small, lightweight, RISC CPU core
// Project:     Zip CPU -- a small, lightweight, RISC CPU core
//
//
// Purpose:     A simple program to handle the disassembly and definition
// Purpose:     A simple program to handle the disassembly and definition
//              of the various Zip Assembly opcodes.  The primary function
//              of the various Zip Assembly opcodes.  The primary function
//              of this file is the zipi_to_string, or Zip Instruction to
//      of this file is the zipi_to_double_string, or Zip Instruction to a
//              string (disassemble) conversion.
//      pair of strings (disassemble) conversion.  The pair of strings is
 
//      necessary since Zip instruction words may contain two separate
 
//      instructions.
//
//
// Creator:     Dan Gisselquist, Ph.D.
// Creator:     Dan Gisselquist, Ph.D.
//              Gisselquist Technology, LLC
//              Gisselquist Technology, LLC
//
//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//
//
// Copyright (C) 2015-2016, Gisselquist Technology, LLC
// Copyright (C) 2015-2017, Gisselquist Technology, LLC
//
//
// This program is free software (firmware): you can redistribute it and/or
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of  the GNU General Public License as published
// modify it under the terms of  the GNU General Public License as published
// by the Free Software Foundation, either version 3 of the License, or (at
// by the Free Software Foundation, either version 3 of the License, or (at
// your option) any later version.
// your option) any later version.
Line 25... Line 27...
// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or
// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
// for more details.
// for more details.
//
//
// You should have received a copy of the GNU General Public License along
// You should have received a copy of the GNU General Public License along
// with this program.  (It's in the $(ROOT)/doc directory, run make with no
// with this program.  (It's in the $(ROOT)/doc directory.  Run make with no
// target there if the PDF file isn't present.)  If not, see
// target there if the PDF file isn't present.)  If not, see
// <http://www.gnu.org/licenses/> for a copy.
// <http://www.gnu.org/licenses/> for a copy.
//
//
// License:     GPL, v3, as defined and found on www.gnu.org,
// License:     GPL, v3, as defined and found on www.gnu.org,
//              http://www.gnu.org/licenses/gpl.html
//              http://www.gnu.org/licenses/gpl.html
//
//
//
//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
 
//
 
//
#include <stdio.h>
#include <stdio.h>
#include <strings.h>
#include <strings.h>
#include <string.h>
#include <string.h>
#include <assert.h>
#include <assert.h>
 
#include <ctype.h>
 
 
#include "twoc.h"
#include "twoc.h"
#include "zopcodes.h"
#include "zopcodes.h"
 
 
const   char    *zop_regstr[] = {
const   char    *zip_regstr[] = {
        "R0", "R1", "R2", "R3",
        "R0", "R1", "R2", "R3",
        "R4", "R5", "R6", "R7",
        "R4", "R5", "R6", "R7",
        "R8", "R9", "R10","R11",
        "R8", "R9", "R10","R11",
        "R12","SP", "CC", "PC",
        "R12","SP", "CC", "PC",
        "uR0", "uR1", "uR2", "uR3",
        "uR0", "uR1", "uR2", "uR3",
Line 55... Line 59...
        "uR8", "uR9", "uR10", "uR11",
        "uR8", "uR9", "uR10", "uR11",
        "uR12", "uSP", "uCC", "uPC",
        "uR12", "uSP", "uCC", "uPC",
        "sR0", "sR1", "sR2", "sR3",
        "sR0", "sR1", "sR2", "sR3",
        "sR4", "sR5", "sR6", "sR7",
        "sR4", "sR5", "sR6", "sR7",
        "sR8", "sR9", "sR10","sR11",
        "sR8", "sR9", "sR10","sR11",
        "sR12","sSP", "sCC", "sPC"
        "sR12","sSP", "sCC", "sPC", "rILL"
};
};
 
 
const   char    *zop_ccstr[] = {
const   char    *zip_ccstr[8] = {
        "", ".LT", ".Z", ".NZ", ".GT", ".GE", ".C", ".V"
        "",  ".Z",  ".LT", ".C",
 
        ".V",".NZ", ".GE", ".NC"
};
};
 
 
const ZOPCODE   zoplist[] = {
static const ZOPCODE    zip_oplist_raw[] = {
        // Special case instructions.  These are general instructions, but with
        // Special case instructions.  These are general instructions, but with
        // special opcodes
        // special opcodes
        // Conditional branches
        // Conditional branches
        //      0.1111.0111.ccc.0.111.10iiiii--
        //      0.1111.0111.ccc.0.111.10iiiii--
        //      0111 1011 11cc c011 110i iiii iiii iiii
        //      0111 1011 11cc c011 110i iiii iiii iiii
        "BUSY", 0xffc7ffff, 0x7883ffff, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
        { "BUSY", 0xffc7ffff, 0x7883ffff, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19) },
        "BRA",  0xfffc0000, 0x78800000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_OPUNUSED,
        { "BZ",  0xfffc0000, 0x78880000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_OPUNUSED },
        "BLT",  0xfffc0000, 0x78880000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_OPUNUSED,
        { "BLT", 0xfffc0000, 0x78900000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_OPUNUSED },
        "BZ",  0xfffc0000, 0x78900000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_OPUNUSED,
        { "BC",  0xfffc0000, 0x78980000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_OPUNUSED },
        "BNZ",  0xfffc0000, 0x78980000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_OPUNUSED,
        { "BV",  0xfffc0000, 0x78a00000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_OPUNUSED },
        "BGT",  0xfffc0000, 0x78a00000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_OPUNUSED,
        { "BNZ",  0xfffc0000, 0x78a80000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_OPUNUSED },
        "BGE",  0xfffc0000, 0x78a80000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_OPUNUSED,
        { "BGE",  0xfffc0000, 0x78b00000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_OPUNUSED },
        "BC",  0xfffc0000, 0x78b00000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_OPUNUSED,
        { "BNC",  0xfffc0000, 0x78b80000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_OPUNUSED },
        "BRV",  0xfffc0000, 0x78b80000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_OPUNUSED,
        { "BRA",  0xffc40000, 0x78800000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        // CLRF ... an XOR w/ self instruction
        // Changes/updates to CC, based upon LDI
        //      0.rrrr.00100.ccc.1.rrrr.iiiii---
        { "TRAP", 0xfffffff0, 0x76000000, ZIP_OPUNUSED,ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED },
        //      0rrr r001 00cc c1rr rr00 0000 0000 0000
        { "TRAP", 0xff800000, 0x76000000, ZIP_OPUNUSED,ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED },
        "CLRF", 0xffc7cfff, 0x01040000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
        // BREV based traps
        "CLRF", 0xffc7cfff, 0x09044000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
        { "TRAP", 0xffc7ffff, 0x72000000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        "CLRF", 0xffc7cfff, 0x11048000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
        // LDILO based traps
        "CLRF", 0xffc7cfff, 0x1904c000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
        { "TRAP",0xffc4ffff, 0x72400000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19) },
        "CLRF", 0xffc7cfff, 0x21050000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
        { "TRAP",0xffc40000, 0x72400000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        "CLRF", 0xffc7cfff, 0x29054000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
 
        "CLRF", 0xffc7cfff, 0x31058000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
 
        "CLRF", 0xffc7cfff, 0x3905c000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
 
        "CLRF", 0xffc7cfff, 0x41060000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
 
        "CLRF", 0xffc7cfff, 0x49064000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
 
        "CLRF", 0xffc7cfff, 0x51068000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
 
        "CLRF", 0xffc7cfff, 0x5906c000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
 
        "CLRF", 0xffc7cfff, 0x61070000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
 
        "CLRF", 0xffc7cfff, 0x69074000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
 
        "CLRF", 0xffc7cfff, 0x71078000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
 
        "CLRF", 0xffc7cfff, 0x7907c000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
 
        // CLR -- a LDI of zero
        // CLR -- a LDI of zero
        //      0.rrrr.1011.iiiiiii--
        //      0.rrrr.1100.iiiiiii--
        //      0rrr r101 1...
        //      0rrr r110 0...
        "CLR",  0x87ffffff, 0x05800000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED,
        { "CLR",  0x87ffffff, 0x06000000, ZIP_REGFIELD(27),ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED },
 
        // BREV based clears
 
        { "CLR", 0x87c7ffff, 0x02000000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        // HALT
        // HALT
        //      0.1110.00011.ccc.0.0000000000010
        //      0.1110.00011.ccc.0.0000000000010
        //      0111.0000.11cc.c000.0000.0000.0000.0010
        //      0111.0000.11cc.c000.0000.0000.0000.0010
        "HALT", 0xffc7ffff, 0x70c00010, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
        { "HALT", 0xffc7ffff, 0x70c00010, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19) },
        // The "wait" instruction is identical, with the only difference being
        // The "wait" instruction is identical, with the only difference being
        // the interrrupt context of the processor.  Well, almost.  To
        // the interrrupt context of the processor.  Well, almost.  To
        // facilitate waits from supervisor mode, the wait instruction
        // facilitate waits from supervisor mode, the wait instruction
        // explicitly forces the CPU into user mode.
        // explicitly forces the CPU into user mode.
        "WAIT", 0xffc7ffff, 0x70c00030, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
        { "WAIT", 0xffc7ffff, 0x70c00030, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19) },
        //
        // 1.0011.11000.000.0000...... 5f ? A carefully chosen illegal insn ??
        // "INT",       0xff10007f, 0x9e00005f, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
        // "INT",       0xff10007f, 0x9e00005f, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
        // Return to user space
        // Return to user space
        "RTU",  0xffc7ffff, 0x70c00020, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
        { "RTU", 0xffc7ffff, 0x70c00020, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19) },
        // The return instruction: JMP R0 (possibly conditional)
        // The return instruction: JMP R0 (possibly conditional) = MOV R0,PC
        "RTN", 0xffc7ffff, 0x7bc00000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
        { "RTN", 0xffc7ffff, 0x7b400000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19) },
        // JMP (possibly a conditional jump, if not covered by branches above)
        // JMP (possibly a conditional jump, if not covered by branches above)
        // 0.1111.01111.ccc.a.rrrr.biiiiiiiiiiiiiiii
        // 0.1111.01101.ccc.a.rrrr.biiiiiiiiiiiiiiii
        // 0111.1011.11cc.c0rr.rrbi.iiii.iiii.iiii      MOV x,PC
        // 0111.1011.01cc.c0rr.rrbi.iiii.iiii.iiii              MOV x,PC
        "JMP",  0xffc40000, 0x7bc00000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_REGFIELD(14), ZIP_IMMFIELD(13,0), ZIP_BITFIELD(3,19),
        { "JMP",  0xffc40000, 0x7b400000, ZIP_OPUNUSED,ZIP_OPUNUSED, ZIP_REGFIELD(14), ZIP_IMMFIELD(13,0), ZIP_BITFIELD(3,19) },
        // 0.1111.1011.ii.iiii.iiii.iiii.iiii.iiii.iiii
        // 0.1111.1100.ii.iiii.iiii.iiii.iiii.iiii.iiii
        // 0111.1101.1iii.iiii.iiii.iiii.iiii.iiii      LDI x,PC
        // 0111.1110.0iii.iiii.iiii.iiii.iiii.iiii              LDI x,PC
        "JMP",  0xff800000, 0x7d800000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(23,0), ZIP_OPUNUSED,
        { "JMPI", 0xff800000, 0x7e000000, ZIP_REGFIELD(27),ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(23,0), ZIP_OPUNUSED },
        // 0.1111.10010.000.1.1111.000000000000000
        // 0.1111.10010.000.1.1111.000000000000000
        // 0111.1100.10cc.c111.11ii.iiii.iiii.iiii              LOD (PC),PC
        // 0111.1100.1000.0111.11ii.iiii.iiii.iiii              LOD (PC),PC
        "LJMP", 0xffffffff, 0x7c87c000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED,
        { "LJMP", 0xffffffff, 0x7c87c000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED },
        "LJMP", 0xffc7ffff, 0x7c87c001, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
 
        // NOT : XOR w/ -1
        // NOT : XOR w/ -1
        //      0.rrrr.00100.ccc.0111.11111111111
        //      0.rrrr.00100.ccc.0111.11111111111
        //      0rrr.r001.00cc.c011.f.f.f.f
        //      0rrr.r001.00cc.c011.f.f.f.f
        "NOT",  0x87c7ffff, 0x0103ffff, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
        // { "NOT", 0x87c7ffff, 0x0103ffff, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19) },
        // General instructions
        // General instructions
        // 0rrr.rooo.oocc.cxrr.rrii.iiii.iiii.iiii
        // 0rrr.rooo.oocc.cxrr.rrii.iiii.iiii.iiii
        "SUB",  0x87c40000, 0x00000000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
        { "SUB", 0x87c40000, 0x00000000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        "SUB",  0x87c40000, 0x00040000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
        { "SUB", 0x87c40000, 0x00040000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        //
 
        "AND",  0x87c40000, 0x00400000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "AND",  0x87c40000, 0x00440000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        //
 
        "ADD",  0x87c40000, 0x00800000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "ADD",  0x87c40000, 0x00840000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        //
 
        "OR",   0x87c40000, 0x00c00000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "OR",   0x87c40000, 0x00c40000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        //
 
        "XOR",  0x87c40000, 0x01000000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "XOR",  0x87c40000, 0x01040000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        //
 
        "LSR",  0x87c40000, 0x01400000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "LSR",  0x87c40000, 0x01440000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        //
 
        "LSL",  0x87c40000, 0x01800000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "LSL",  0x87c40000, 0x01840000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        //
 
        "ASR",  0x87c40000, 0x01c00000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "ASR",  0x87c40000, 0x01c40000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        //
 
#ifdef  LONG_MPY
 
        "MPY",0x87c40000, 0x02000000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "MPY",0x87c40000, 0x02040000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
#else
 
        "LDIHI",0x87c40000, 0x02000000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "LDIHI",0x87c40000, 0x02040000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
#endif
 
        //
 
        "LDILO",0x87c40000, 0x02400000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "LDILO",0x87c40000, 0x02440000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        //
 
#ifdef  LONG_MPY
 
        //
 
        "MPYUHI", 0x87c40000, 0x02800000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "MPYUHI", 0x87c40000, 0x02840000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        //
 
        "MPYSHI", 0x87c40000, 0x02c00000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "MPYSHI", 0x87c40000, 0x02c40000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
#else
 
        "MPYU", 0x87c40000, 0x02800000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "MPYU", 0x87c40000, 0x02840000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        //
 
        "MPYS", 0x87c40000, 0x02c00000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "MPYS", 0x87c40000, 0x02c40000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
#endif
 
        //
 
        "BREV", 0x87c40000, 0x03000000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "BREV", 0x87c40000, 0x03040000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        //
 
        "POPC", 0x87c40000, 0x03400000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "POPC", 0x87c40000, 0x03440000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        //
 
        "ROL",  0x87c40000, 0x03800000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "ROL",  0x87c40000, 0x03840000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        //
 
        // map bit = 1 (interrupts enabled) specifies user reg
 
        // 0rrr.rooo.oocc.cxrr.rrxi.iiii.iiii.iiii
 
        "MOV",  0x87c42000, 0x03c00000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(14), ZIP_IMMFIELD(13,0), ZIP_BITFIELD(3,19),
 
        "MOV",  0x87c42000, 0x03c40000, ZIP_URGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(14), ZIP_IMMFIELD(13,0), ZIP_BITFIELD(3,19),
 
        "MOV",  0x87c42000, 0x03c02000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_URGFIELD(14), ZIP_IMMFIELD(13,0), ZIP_BITFIELD(3,19),
 
        "MOV",  0x87c42000, 0x03c42000, ZIP_URGFIELD(27), ZIP_OPUNUSED, ZIP_URGFIELD(14), ZIP_IMMFIELD(13,0), ZIP_BITFIELD(3,19),
 
        //
 
        "CMP",  0x87c40000, 0x04000000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "CMP",  0x87c40000, 0x04040000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        "TST",  0x87c40000, 0x04400000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "TST",  0x87c40000, 0x04440000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        // 0rrr.r101.1
 
        "LDI",  0x87800000, 0x05800000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(23,0), ZIP_OPUNUSED,
 
        //
 
        // 0.111x.00000.xxx.xxx.xxxx.xxxx.xxxx.xxxx
 
        // 0111.x000.00.xxx.xxx.xxxx.xxxx.xxxx.xxxx
 
        "NOOP",  0xf7ffffff, 0x76000000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        "BRK",   0xf7ffffff, 0x76400000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        "BRK",   0xf7fc0000, 0x76400000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_OPUNUSED,
 
        "LOCK",  0xf7f80000, 0x76800000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        //
 
        //
 
        // LOD: 0rrr.r100.10cc.cxrr.rrii.iiii.iiii.iiii
 
        "LOD",  0x87c40000, 0x04800000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "LOD",  0x87c40000, 0x04840000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        //
 
        "STO",  0x87c40000, 0x04c00000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "STO",  0x87c40000, 0x04c40000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        //
 
        // 0rrr.r101.1dcc.cxrr.rrii.iiii.iiii.iiii
 
        "DIVU", 0x87c40000, 0x05000000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "DIVU", 0x87c40000, 0x05040000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        "DIVS", 0x87c40000, 0x05400000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "DIVS", 0x87c40000, 0x05440000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        //
 
        // 0rrr.r11f.ffcc.cxrr.rrii.iiii.iiii.iiii
 
        "FPADD",0x87c43fff, 0x06040000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
 
        "FPSUB",0x87c43fff, 0x06440000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
 
        "FPMPY",0x87c43fff, 0x06840000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
 
        "FPDIV",0x87c43fff, 0x06c40000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
 
        "FPCVT",0x87c40000, 0x07000000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19),
 
        "FPCVT",0x87c40000, 0x07040000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        "FPINT",0x87c40000, 0x07440000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19),
 
        //
 
        //
 
        //
 
        //
 
        //
        //
        //      16-bit instructions, high side
        { "AND", 0x87c40000, 0x00400000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        //
        { "AND", 0x87c40000, 0x00440000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        // 
 
        //      1.1111.00010.xcc.0iiii.xxxx.xxxxx.xxxxx
 
        //      1111.1000.10xc.c0ii.iixx.xxxx.xxxx.xxxx
 
        "BRA",  0xffd40000, 0xf8800000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_OPUNUSED,
 
        "BLT",  0xffd40000, 0xf8840000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_OPUNUSED,
 
        "BZ",  0xffd40000, 0xf8900000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_OPUNUSED,
 
        "BNZ",  0xffd40000, 0xf8940000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_OPUNUSED,
 
        // LDI  1.rrrr.1011x.ccc.iiiii  -> 1rrr r101 1xcc ciii ii
 
        "CLR",  0x8787c000, 0x85800000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        // RTN  1.1111.01111.ccc.1.0000 -> 1111.1011.11cc.c100.00 (Mov R0 to PC)
 
        "RTN", 0xffc7c000, 0xfbc40000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
 
        // JMP  1.1111.01111.ccc.1rrrr  -> 1111 1011 11cc c1rr rr (Mov to PC)
 
        "JMP",  0xffc40000, 0xfbc40000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        // XOR  1.rrrr.00100.ccc.01111  -> 1rrr r001 00cc c011 11
 
        "NOT",  0x87c7c000, 0x8103c000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        // General instructions, top half
 
        // 1rrr.rooo.oocc.cxrr.rr
 
        "SUB",  0x87c40000, 0x80000000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_BITFIELD(2,19),
 
        "SUB",  0x87c40000, 0x80040000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        //
 
        "AND",  0x87c40000, 0x80400000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_BITFIELD(2,19),
 
        "AND",  0x87c40000, 0x80440000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        //
        //
        "ADD",  0x87c40000, 0x80800000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_BITFIELD(2,19),
        { "ADD", 0x87c40000, 0x00800000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        "ADD",  0x87c40000, 0x80840000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "ADD", 0x87c40000, 0x00840000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        //
        //
        "OR",   0x87c40000, 0x80c00000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_BITFIELD(2,19),
        { "OR", 0x87c40000, 0x00c00000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        "OR",   0x87c40000, 0x80c40000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "OR", 0x87c40000, 0x00c40000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        //
        //
        "XOR",  0x87c40000, 0x81000000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_BITFIELD(2,19),
        { "XOR", 0x87c40000, 0x01000000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        "XOR",  0x87c40000, 0x81040000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "XOR", 0x87c40000, 0x01040000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        //
        //
        "LSR",  0x87c40000, 0x81400000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_BITFIELD(2,19),
        { "LSR", 0x87c40000, 0x01400000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        "LSR",  0x87c40000, 0x81440000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "LSR", 0x87c40000, 0x01440000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        //
        //
        "LSL",  0x87c40000, 0x81800000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_BITFIELD(2,19),
        { "LSL", 0x87c40000, 0x01800000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        "LSL",  0x87c40000, 0x81840000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "LSL", 0x87c40000, 0x01840000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        //
        //
        "ASR",  0x87c40000, 0x81c00000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_BITFIELD(2,19),
        { "ASR", 0x87c40000, 0x01c00000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        "ASR",  0x87c40000, 0x81c40000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "ASR", 0x87c40000, 0x01c40000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        //
        //
#ifdef  LONG_MPY
        { "BREV",0x87c40000, 0x02000000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        "MPY",0x87c40000, 0x82000000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(5,14), ZIP_BITFIELD(2,19),
        { "BREV",0x87c40000, 0x02040000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
#else
 
        "LDIHI",0x87c40000, 0x82000000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(5,14), ZIP_BITFIELD(2,19),
 
#endif
 
        "LDILO",0x87c40000, 0x82400000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(5,14), ZIP_BITFIELD(2,19),
 
#ifdef  LONG_MPY
 
        //
        //
        "MPYUHI", 0x87c40000, 0x82800000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_BITFIELD(2,19),
        { "LDILO",0x87c40000, 0x02400000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        "MPYUHI", 0x87c40000, 0x82840000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "LDILO",0x87c40000, 0x02440000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        //
        //
        "MPYSHI", 0x87c40000, 0x82c00000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_BITFIELD(2,19),
 
        "MPYSHI", 0x87c40000, 0x82c40000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
#else
 
        //
        //
        "MPYU", 0x87c40000, 0x82800000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_BITFIELD(2,19),
        { "MPYUHI", 0x87c40000, 0x02800000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        "MPYU", 0x87c40000, 0x82840000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "MPYUHI", 0x87c40000, 0x02840000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        //
        //
        "MPYS", 0x87c40000, 0x82c00000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_BITFIELD(2,19),
        { "MPYSHI", 0x87c40000, 0x02c00000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        "MPYS", 0x87c40000, 0x82c40000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "MPYSHI", 0x87c40000, 0x02c40000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
#endif
 
        // brev
 
        "BREV", 0x87c40000, 0x83000000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_BITFIELD(2,19),
 
        "BREV", 0x87c40000, 0x83040000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        //
        //
        "POPC", 0x87c40000, 0x83400000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_BITFIELD(2,19),
        { "MPY", 0x87c40000, 0x03000000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        "POPC", 0x87c40000, 0x83440000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "MPY", 0x87c40000, 0x03040000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        //
        //
        "ROL",  0x87c40000, 0x83800000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_BITFIELD(2,19),
        { "MOV", 0x87c42000, 0x03400000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(14), ZIP_IMMFIELD(13,0), ZIP_BITFIELD(3,19) },
        "ROL",  0x87c40000, 0x83840000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "MOV", 0x87c42000, 0x03440000, ZIP_URGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(14), ZIP_IMMFIELD(13,0), ZIP_BITFIELD(3,19) },
 
        { "MOV", 0x87c42000, 0x03402000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_URGFIELD(14), ZIP_IMMFIELD(13,0), ZIP_BITFIELD(3,19) },
 
        { "MOV", 0x87c42000, 0x03442000, ZIP_URGFIELD(27), ZIP_OPUNUSED, ZIP_URGFIELD(14), ZIP_IMMFIELD(13,0), ZIP_BITFIELD(3,19) },
        //
        //
        "MOV",  0x87c40000, 0x83c40000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "DIVU", 0x87c40000, 0x03800000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
 
        { "DIVU", 0x87c40000, 0x03840000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        //
        //
        "CMP",  0x87c40000, 0x84000000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_BITFIELD(2,19),
        { "DIVS", 0x87c40000, 0x03c00000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        "CMP",  0x87c40000, 0x84040000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "DIVS", 0x87c40000, 0x03c40000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        //
        //
        "TST",  0x87c40000, 0x84400000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_BITFIELD(2,19),
        { "CMP", 0x87c40000, 0x04000000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        "TST",  0x87c40000, 0x84440000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "CMP", 0x87c40000, 0x04040000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
 
        { "TST", 0x87c40000, 0x04400000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
 
        { "TST", 0x87c40000, 0x04440000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        //
        //
        "LOD",  0x87c40000, 0x84840000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "LW", 0x87c40000, 0x04800000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
 
        { "LW", 0x87c40000, 0x04840000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        //
        //
        "STO",  0x87c40000, 0x84c40000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "SW", 0x87c40000, 0x04c00000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
 
        { "SW", 0x87c40000, 0x04c40000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        //
        //
        "DIVU", 0x87c40000, 0x85000000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_BITFIELD(2,19),
        { "LH", 0x87c40000, 0x05000000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        "DIVU", 0x87c40000, 0x85040000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "LH", 0x87c40000, 0x05040000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        //
        //
        "DIVS", 0x87c40000, 0x85400000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_BITFIELD(2,19),
        { "SH", 0x87c40000, 0x05400000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        "DIVS", 0x87c40000, 0x85440000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "SH", 0x87c40000, 0x05440000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        //
        //
        "CLR",  0x8787c000, 0x85800000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "LB", 0x87c40000, 0x05800000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
        "LDI",  0x87c00000, 0x85800000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(5,14), ZIP_BITFIELD(2,19),
        { "LB", 0x87c40000, 0x05840000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        //
        //
        "NOOP", 0xf7c00000, 0xf6000000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED,
        { "SB", 0x87c40000, 0x05c00000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
 
        { "SB", 0x87c40000, 0x05c40000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        //
        //
        "BRK",  0xf7c7c000, 0xf6400000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED,
        // 0rrr.r101.1
        "BRK",  0xf7c40000, 0xf6400000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_OPUNUSED,
        { "LDI",  0x87800000, 0x06000000, ZIP_REGFIELD(27),ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(23,0), ZIP_OPUNUSED },
 
        // 0111.x111.00.xxxxxxxx
 
        { "BRK",   0xf7ffffff, 0x77000000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED },
 
        { "BRK",   0xf7c00000, 0x77000000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(22,0), ZIP_OPUNUSED },
 
        { "LOCK",  0xf7ffffff, 0x77400000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED },
 
        { "LOCK",  0xf7c00000, 0x77400000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(22,0), ZIP_OPUNUSED },
 
        // 0.111x.00000.xxx.xxx.xxxx.xxxx.xxxx.xxxx
 
        // 0111.x111.11.xxx.xxx.xxxx.xxxx.xxxx.xxxx
 
        // SNOOP = SIM w/ no argument(s)
 
        { "SIM",  0xf7ffffff, 0x77800000, ZIP_OPUNUSED, ZIP_OPUNUSED,    ZIP_OPUNUSED, ZIP_OPUNUSED,       ZIP_OPUNUSED },
 
        { "SEXIT",0xf7ffffff, 0x77800100, ZIP_OPUNUSED, ZIP_OPUNUSED,    ZIP_OPUNUSED, ZIP_OPUNUSED,       ZIP_OPUNUSED },
 
        { "SEXIT",0xf7fffff0, 0x77800310, ZIP_OPUNUSED, ZIP_URGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,       ZIP_OPUNUSED },
 
        { "SEXIT",0xf7ffffe0, 0x77800300, ZIP_OPUNUSED, ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,       ZIP_OPUNUSED },
 
        { "SEXIT",0xf7ffff00, 0x77800100, ZIP_OPUNUSED, ZIP_OPUNUSED,    ZIP_OPUNUSED, ZIP_IMMFIELD( 8,0), ZIP_OPUNUSED },
 
        { "SDUMP",0xf7ffffff, 0x778002ff, ZIP_OPUNUSED, ZIP_OPUNUSED,    ZIP_OPUNUSED, ZIP_OPUNUSED,       ZIP_OPUNUSED },
 
        { "SDUMP",0xf7fffff0, 0x77800200, ZIP_OPUNUSED, ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,       ZIP_OPUNUSED },
 
        { "SDUMP",0xf7fffff0, 0x77800210, ZIP_OPUNUSED, ZIP_URGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,       ZIP_OPUNUSED },
 
        { "SOUT", 0xf7fffff0, 0x77800230, ZIP_OPUNUSED, ZIP_URGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,       ZIP_OPUNUSED },
 
        { "SOUT", 0xf7ffffe0, 0x77800220, ZIP_OPUNUSED, ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,       ZIP_OPUNUSED },
 
        { "SOUT", 0xf7ffff00, 0x77800400, ZIP_OPUNUSED, ZIP_OPUNUSED,    ZIP_OPUNUSED, ZIP_IMMFIELD( 8,0), ZIP_OPUNUSED },
 
        { "SDUMP",0xf7ffff00, 0x77800200, ZIP_OPUNUSED, ZIP_OPUNUSED,    ZIP_OPUNUSED, ZIP_IMMFIELD( 8,0), ZIP_OPUNUSED },
 
        { "SIM",  0xf7c00000, 0x77800000, ZIP_OPUNUSED, ZIP_OPUNUSED,    ZIP_OPUNUSED, ZIP_IMMFIELD(22,0), ZIP_OPUNUSED },
 
        { "NOOP", 0xf7ffffff, 0x77c00000, ZIP_OPUNUSED, ZIP_OPUNUSED,    ZIP_OPUNUSED, ZIP_OPUNUSED,       ZIP_OPUNUSED },
 
        { "NEXIT",0xf7ffffff, 0x77c00100, ZIP_OPUNUSED, ZIP_OPUNUSED,    ZIP_OPUNUSED, ZIP_OPUNUSED,       ZIP_OPUNUSED },
 
        { "NEXIT",0xf7ffff00, 0x77c00100, ZIP_OPUNUSED, ZIP_OPUNUSED,    ZIP_OPUNUSED, ZIP_IMMFIELD( 8,0), ZIP_OPUNUSED },
 
        { "NEXIT",0xf7fffff0, 0x77c00310, ZIP_OPUNUSED, ZIP_URGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,       ZIP_OPUNUSED },
 
        { "NEXIT",0xf7ffffe0, 0x77c00300, ZIP_OPUNUSED, ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,       ZIP_OPUNUSED },
 
        { "NDUMP",0xf7ffffff, 0x77c002ff, ZIP_OPUNUSED, ZIP_OPUNUSED,    ZIP_OPUNUSED, ZIP_OPUNUSED,       ZIP_OPUNUSED },
 
        { "NDUMP",0xf7fffff0, 0x77c00200, ZIP_OPUNUSED, ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,       ZIP_OPUNUSED },
 
        { "NDUMP",0xf7fffff0, 0x77c00210, ZIP_OPUNUSED, ZIP_URGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,       ZIP_OPUNUSED },
 
 
 
        { "NOUT", 0xf7fffff0, 0x77c00230, ZIP_OPUNUSED, ZIP_URGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,       ZIP_OPUNUSED },
 
        { "NOUT", 0xf7ffffe0, 0x77c00220, ZIP_OPUNUSED, ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,       ZIP_OPUNUSED },
 
        { "NOUT", 0xf7ffff00, 0x77c00400, ZIP_OPUNUSED, ZIP_OPUNUSED,    ZIP_OPUNUSED, ZIP_IMMFIELD( 8,0), ZIP_OPUNUSED },
 
        { "NDUMP",0xf7ffff00, 0x77c00200, ZIP_OPUNUSED, ZIP_OPUNUSED,    ZIP_OPUNUSED, ZIP_OPUNUSED,       ZIP_OPUNUSED },
 
        { "NSIM", 0xf7c00000, 0x77c00000, ZIP_OPUNUSED, ZIP_OPUNUSED,    ZIP_OPUNUSED, ZIP_IMMFIELD(22,0), ZIP_OPUNUSED },
        //
        //
        "LOCK", 0xf7c00000, 0xf6800000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        //
        //
 
        // 0rrr.r11f.ffcc.cxrr.rrii.iiii.iiii.iiii
 
        { "FPADD",0x87c43fff, 0x06840000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(3,19) },
 
        { "FPSUB",0x87c43fff, 0x06c40000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(3,19) },
 
        { "FPMPY",0x87c43fff, 0x07040000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(3,19) },
 
        { "FPDIV",0x87c43fff, 0x07440000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(3,19) },
 
        { "FPI2F",0x87c40000, 0x07800000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(18,0), ZIP_BITFIELD(3,19) },
 
        { "FPI2F",0x87c40000, 0x07840000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
 
        { "FPF2I",0x87c40000, 0x07c40000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(14), ZIP_IMMFIELD(14,0), ZIP_BITFIELD(3,19) },
        //
        //
        "FPADD",0x87c40000, 0x86040000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        //
        //
        "FPSUB",0x87c40000, 0x86440000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        //
        //
        "FPMUL",0x87c40000, 0x86840000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        //
        //
        "FPDIV",0x87c40000, 0x86c40000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        //
        //
        "FPCVT",0x87c40000, 0x87000000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(4,14), ZIP_BITFIELD(2,19),
        //      16-bit instructions, high side
        "FPCVT",0x87c40000, 0x87040000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        //
        //
        "FPINT",0x87c40000, 0x87440000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(14), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        //
        //
 
        //      1.1111.00010.xcc.0iiii.xxxx.xxxxx.xxxxx
 
        //      1111.1000.10xc.c0ii.iixx.xxxx.xxxx.xxxx
 
        // Mask, val, result, Ra, Rb, I, condition (no conditions for OP_UNDER_TEST)
 
        // BRA: 1.1111.011.0.sssssss
 
        { "BRA", 0xff800000, 0xf9000000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(7,16), ZIP_OPUNUSED },
 
        // CLR: 1.rrrr.110.00000000
 
        { "CLR", 0x87ff0000, 0x86000000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED },
 
        // RTN: 1.1111.111.0.0000.000, MOV R0,Pc
 
        { "RTN", 0xffff0000, 0xff800000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED },
 
        // JMP: 1.1111.111.0.rrrrsss
 
        { "JMP", 0xff800000, 0xff000000, ZIP_REGFIELD(27),ZIP_OPUNUSED, ZIP_REGFIELD(19), ZIP_IMMFIELD(3,16), ZIP_OPUNUSED },
 
        // LJSR: 1.000_0.011_.0.111_1.001 ?.1111.110.1.1111.000
 
        // { "LJSR",0xffffffff, 0x83797ef8, ZIP_REGFIELD(27),ZIP_OPUNUSED, ZIP_REGFIELD(19), ZIP_IMMFIELD(3,16), ZIP_OPUNUSED },
 
        //
 
        // 1.rrrr.000.0.sssssss
 
        // 1rrr.r000.0sss.ssss
 
        { "SUB", 0x87800000, 0x80000000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(7,16), ZIP_OPUNUSED },
 
        // 1.rrrr.000.1.rrrrsss
 
        { "SUB", 0x87800000, 0x80800000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(19), ZIP_IMMFIELD(3,16), ZIP_OPUNUSED },
 
        //
 
        // 1.rrrr.001.0.sssssss
 
        // 1.rrrr.001.1.rrrrsss
 
        { "AND", 0x87800000, 0x81000000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(7,16), ZIP_OPUNUSED },
 
        { "AND", 0x87800000, 0x81800000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(19), ZIP_IMMFIELD(3,16), ZIP_OPUNUSED },
 
        //
 
        // 1.rrrr.010.0.sssssss
 
        // 1.rrrr.010.1.rrrrsss
 
        { "ADD", 0x87800000, 0x82000000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_IMMFIELD(7,16), ZIP_OPUNUSED },
 
        { "ADD", 0x87800000, 0x82800000, ZIP_REGFIELD(27), ZIP_REGFIELD(27), ZIP_REGFIELD(19), ZIP_IMMFIELD(3,16), ZIP_OPUNUSED },
 
        //
 
        // 1.rrrr.011.a.rrrrsss
 
        { "CMP", 0x87800000, 0x83000000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(19), ZIP_IMMFIELD(7,16), ZIP_OPUNUSED },
 
        { "CMP", 0x87800000, 0x83800000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(19), ZIP_IMMFIELD(3,16), ZIP_OPUNUSED },
 
        //
 
        // 1.rrrr.100.0.sssssss
 
        // 1.rrrr.100.1.rrrrsss
 
        { "LW", 0x87800000, 0x84000000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_SP, ZIP_IMMFIELD(7,16), ZIP_OPUNUSED },
 
        { "LW", 0x87800000, 0x84800000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_REGFIELD(19), ZIP_IMMFIELD(3,16), ZIP_OPUNUSED },
 
        // 1.rrrr.101.ssssssss
 
        { "SW", 0x87800000, 0x85000000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_SP, ZIP_IMMFIELD(7,16), ZIP_OPUNUSED },
 
        // 1.rrrr.110.0.sssssss
 
        { "SW", 0x87800000, 0x85800000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_REGFIELD(19), ZIP_IMMFIELD(3,16), ZIP_OPUNUSED },
 
        // 1.rrrr.110.iiiiiiii
 
        { "LDI", 0x87000000, 0x86000000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(8,16), ZIP_OPUNUSED },
 
        // 1.rrrr.111.1.sssssss
 
        { "MOV", 0x87800000, 0x87800000, ZIP_OPUNUSED, ZIP_REGFIELD(27), ZIP_REGFIELD(19), ZIP_IMMFIELD(3,16), ZIP_OPUNUSED },
        //
        //
 
        // 1.rrrr.111.1.rrrrsss
        // Illegal instruction !!
        // Illegal instruction !!
        "ILL",  0x00000000, 0x00000000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(32,0), ZIP_OPUNUSED
        { "ILLV", 0x80000000, 0x80000000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(32,16), ZIP_OPUNUSED },
 
        // Global illegal instruction
 
        { "ILL", 0x00000000, 0x00000000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(32,0), ZIP_OPUNUSED }
};
};
 
 
const ZOPCODE   zbottomlist[] = {
static const ZOPCODE    zip_opbottomlist_raw[] = {
        //
        //
        //
        //
        //
        //
        //      16-bit instructions, low side ... treat these as special
        //      16-bit instructions, low side ... treat these as special
        //
        //
        //
        //
        // Special case instructions.  These are general instructions, but with
        // Mask, val, result, Ra, Rb, I, condition (no conditions for OP_UNDER_TEST)
        // special opcodes
        // BRA: 1.xxx_xxxx_xxxx_xxxx_?.111_1.011.0.sssssss
        // Conditional branches
        { "BRA", 0x80007f80, 0x80007900, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(7,0), ZIP_OPUNUSED },
        //      1.xxxx.xxxxx.1cc.xxxxx.1111.00010.0iiii
        // CLR: 1.xxx_xxxx_xxxx_xxxx_?.rrr_r.101.0000_0000
        //      1xxx.xxxx.xx1c.cxxx.xx11.1100.0100.iiii
        { "CLR", 0x800007ff, 0x80000600, ZIP_REGFIELD(11), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED },
        "BRA",  0x80203ff0, 0x80003c40, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
        // RTN: 1.1111.111.0.0000.000, MOV R0,Pc
        "BLT",  0x80383ff0, 0x80283c40, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
        { "RTN", 0x80007fff, 0x80007f80, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED },
        "BZ",  0x80383ff0, 0x80303c40, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
        // JMP: 1.1111.111.0.rrrrsss
        "BNZ",  0x80383ff0, 0x80383c40, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
        { "JMP", 0x80007f80, 0x80007f00, ZIP_REGFIELD(11),ZIP_OPUNUSED, ZIP_REGFIELD(3), ZIP_IMMFIELD(3,0), ZIP_OPUNUSED },
        //
        // LJMP: 1.xxx_xxxx_xxxx_xxxx_?.111_1.100._1.111_1.000
        "LJMP", 0x80203fff, 0x80003e5f, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED,
        { "LJMP", 0x80007fff, 0x80007cf8, ZIP_REGFIELD(11), ZIP_OPUNUSED, ZIP_REGFIELD(3), ZIP_IMMFIELD(3,0), ZIP_OPUNUSED },
        //
        //
        //
        // 1.rrrr.000.0.sssssss
        // CLRF ... an XOR w/ self instruction
        { "SUB", 0x80000780, 0x80000000, ZIP_REGFIELD(11), ZIP_REGFIELD(11), ZIP_OPUNUSED, ZIP_IMMFIELD(7,0), ZIP_OPUNUSED },
        //      0.rrrr.00100.ccc.1.rrrr.iiiii---
        // 1.rrrr.000.1.rrrrsss
        //      0rrr r001 00cc c1rr rr00 0000 0000 0000
        { "SUB", 0x80000780, 0x80000080, ZIP_REGFIELD(11), ZIP_REGFIELD(11), ZIP_REGFIELD(3), ZIP_IMMFIELD(3,0), ZIP_OPUNUSED },
        // "CLRF",      0xffc7cfff, 0x7907c000, ZIP_REGFIELD(27), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(3,19),
        //
        // CLR -- a LDI of zero
        // 1.rrrr.001.0.sssssss
        // LDI  1xxx.xxxx.xxxx.xxxx.xxrr.rroo.ooo.iiiii -> 1rrr r100 1xcc ciii ii
        // 1.rrrr.001.1.rrrrsss
        // RTN  1xxx -- xx11.1101.111.ccc.1.0000 -> 1xxx --- xx11.1101.1111.0000
        { "AND", 0x80000780, 0x80000100, ZIP_REGFIELD(11), ZIP_REGFIELD(11), ZIP_OPUNUSED, ZIP_IMMFIELD(7,0), ZIP_OPUNUSED },
        "RTN", 0x80203fff, 0x80003df0, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED,
        { "AND", 0x80000780, 0x80000180, ZIP_REGFIELD(11), ZIP_REGFIELD(11), ZIP_REGFIELD(3), ZIP_IMMFIELD(3,0), ZIP_OPUNUSED },
        "RTN", 0x80203fff, 0x80203df0, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        //
        // JMP  1xxx -- xx11.1101.1111.rrrr (Mov to PC)
        // 1.rrrr.010.0.sssssss
        "JMP",  0x80203ff0, 0x80003df0, ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
        // 1.rrrr.010.1.rrrrsss
        // Conditional jump, still move to PC at issue
        { "ADD", 0x80000780, 0x80000200, ZIP_REGFIELD(11), ZIP_REGFIELD(11), ZIP_OPUNUSED, ZIP_IMMFIELD(7,0), ZIP_OPUNUSED },
        "JMP",  0x80203ff0, 0x80203df0, ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "ADD", 0x80000780, 0x80000280, ZIP_REGFIELD(11), ZIP_REGFIELD(11), ZIP_REGFIELD(3), ZIP_IMMFIELD(3,0), ZIP_OPUNUSED },
        //
        //
        // XOR  1xxx -- xx00.1000.1111  -> 1rrr r001 00cc c011 11
        // 1.rrrr.011.a.rrrrsss
        "NOT",  0x802003ff, 0x8000008f, ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED,
        { "CMP", 0x80000780, 0x80000300, ZIP_REGFIELD(11), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(7,0), ZIP_OPUNUSED },
        "NOT",  0x802003ff, 0x8020008f, ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "CMP", 0x80000780, 0x80000380, ZIP_REGFIELD(11), ZIP_OPUNUSED, ZIP_REGFIELD(3), ZIP_IMMFIELD(3,0), ZIP_OPUNUSED },
        // General instructions, bottom half
        //
        // 1xxx -- xxrr.rroo.ooox.rrrr
        // 1.rrrr.100.0.sssssss
        "SUB",  0x800003f0, 0x80000000, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_BITFIELD(2,19),
        // 1.rrrr.100.1.rrrrsss
        "SUB",  0x802003f0, 0x80200000, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
        { "LW", 0x80000780, 0x80000400, ZIP_REGFIELD(11), ZIP_OPUNUSED, ZIP_SP, ZIP_IMMFIELD(7,0), ZIP_OPUNUSED },
        "SUB",  0x800003f0, 0x80000010, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "LW", 0x80000780, 0x80000480, ZIP_REGFIELD(11), ZIP_OPUNUSED, ZIP_REGFIELD(3), ZIP_IMMFIELD(3,0), ZIP_OPUNUSED },
        "SUB",  0x802003f0, 0x80200010, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
        // 1.rrrr.101.ssssssss
        //
        { "SW", 0x80000780, 0x80000500, ZIP_OPUNUSED, ZIP_REGFIELD(11), ZIP_SP, ZIP_IMMFIELD(7,0), ZIP_OPUNUSED },
        "AND",  0x800003f0, 0x80000020, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_BITFIELD(2,19),
        { "SW", 0x80000780, 0x80000580, ZIP_OPUNUSED, ZIP_REGFIELD(11), ZIP_REGFIELD(3), ZIP_IMMFIELD(3,0), ZIP_OPUNUSED },
        "AND",  0x802003f0, 0x80200020, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
        // 1.rrr_r.110.ssssssss
        "AND",  0x800003f0, 0x80000030, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
        { "LDI", 0x80000700, 0x80000600, ZIP_REGFIELD(11), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(8,0), ZIP_OPUNUSED },
        "AND",  0x802003f0, 0x80200030, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
        // 1.rrr_r.111_.x.rrr_rsss
        //
        { "MOV", 0x80000780, 0x80000780, ZIP_REGFIELD(11), ZIP_OPUNUSED, ZIP_REGFIELD(3), ZIP_IMMFIELD(3,0), ZIP_OPUNUSED },
        "ADD",  0x800003f0, 0x80000040, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_BITFIELD(2,19),
 
        "ADD",  0x802003f0, 0x80200040, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
 
        "ADD",  0x800003f0, 0x80000050, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "ADD",  0x802003f0, 0x80200050, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        //
 
        "OR",   0x800003f0, 0x80000060, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_BITFIELD(2,19),
 
        "OR",   0x802003f0, 0x80200060, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
 
        "OR",   0x800003f0, 0x80000070, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "OR",   0x802003f0, 0x80200070, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        //
 
        "XOR",  0x800003f0, 0x80000080, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_BITFIELD(2,19),
 
        "XOR",  0x802003f0, 0x80200080, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
 
        "XOR",  0x800003f0, 0x80000090, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "XOR",  0x802003f0, 0x80200090, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        //
 
        "LSR",  0x800003f0, 0x800000a0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_BITFIELD(2,19),
 
        "LSR",  0x802003f0, 0x802000a0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
 
        "LSR",  0x800003f0, 0x800000b0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "LSR",  0x802003f0, 0x802000b0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        //
 
        "LSL",  0x800003f0, 0x800000c0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_BITFIELD(2,19),
 
        "LSL",  0x802003f0, 0x802000c0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
 
        "LSL",  0x800003f0, 0x800000d0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "LSL",  0x802003f0, 0x802000d0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        //
 
        "ASR",  0x800003f0, 0x800000e0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_BITFIELD(2,19),
 
        "ASR",  0x802003f0, 0x802000e0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
 
        "ASR",  0x800003f0, 0x800000f0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "ASR",  0x802003f0, 0x802000f0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
#ifdef  LONG_MPY
 
        //
 
        "MPY",0x800003e0, 0x80000100, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(5,0), ZIP_BITFIELD(2,19),
 
        "MPY",0x802003e0, 0x80200100, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(5,0), ZIP_OPUNUSED,
 
#else
 
        //
 
        "LDIHI",0x800003e0, 0x80000100, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(5,0), ZIP_BITFIELD(2,19),
 
        "LDIHI",0x802003e0, 0x80200100, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(5,0), ZIP_OPUNUSED,
 
#endif
 
        // ldilo
 
        "LDILO",0x800003e0, 0x80000120, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(5,0), ZIP_BITFIELD(2,19),
 
        "LDILO",0x802003e0, 0x80200120, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(5,0), ZIP_OPUNUSED,
 
        //
 
#ifdef  LONG_MPY
 
        "MPYUHI", 0x800003f0, 0x80000140, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_BITFIELD(2,19),
 
        "MPYUHI", 0x802003f0, 0x80200140, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
 
        "MPYUHI", 0x800003f0, 0x80000150, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "MPYUHI", 0x802003f0, 0x80200150, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        //
 
        "MPYSHI", 0x800003f0, 0x80000160, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_BITFIELD(2,19),
 
        "MPYSHI", 0x802003f0, 0x80200160, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
 
        "MPYSHI", 0x800003f0, 0x80000170, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "MPYSHI", 0x802003f0, 0x80200170, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED },
 
        //
 
#else
 
        "MPYU", 0x800003f0, 0x80000140, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_BITFIELD(2,19),
 
        "MPYU", 0x802003f0, 0x80200140, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
 
        "MPYU", 0x800003f0, 0x80000150, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "MPYU", 0x802003f0, 0x80200150, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        // ad
 
        "MPYS", 0x800003f0, 0x80000160, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_BITFIELD(2,19),
 
        "MPYS", 0x802003f0, 0x80200160, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
 
        "MPYS", 0x800003f0, 0x80000170, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "MPYS", 0x802003f0, 0x80200170, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        // mpe
 
#endif
 
        //
 
        "BREV", 0x800003f0, 0x80000180, ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_BITFIELD(2,19),
 
        "BREV", 0x802003f0, 0x80200180, ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
 
        "BREV", 0x800003f0, 0x80000190, ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "BREV", 0x802003f0, 0x80200190, ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        // popc
 
        "POPC", 0x800003f0, 0x800001a0, ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_BITFIELD(2,19),
 
        "POPC", 0x802003f0, 0x802001a0, ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
 
        "POPC", 0x800003f0, 0x800001b0, ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "POPC", 0x802003f0, 0x802001b0, ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        // rol
 
        "ROL",  0x800003f0, 0x800001c0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_BITFIELD(2,19),
 
        "ROL",  0x802003f0, 0x802001c0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
 
        "ROL",  0x800003f0, 0x800001d0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "ROL",  0x802003f0, 0x802001d0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        // mov
 
        "MOV",  0x800003f0, 0x800001f0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "MOV",  0x802003f0, 0x802001f0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        // cmp
 
        "CMP",  0x800003f0, 0x80000200, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_BITFIELD(2,19),
 
        "CMP",  0x802003f0, 0x80200200, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
 
        "CMP",  0x800003f0, 0x80000210, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "CMP",  0x802003f0, 0x80200210, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        //
 
        "TST",  0x800003f0, 0x80000220, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_BITFIELD(2,19),
 
        "TST",  0x802003f0, 0x80200220, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
 
        "TST",  0x800003f0, 0x80000230, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "TST",  0x802003f0, 0x80200230, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        // Loads
 
        "LOD",  0x800003f0, 0x80000250, ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "LOD",  0x802003f0, 0x80200250, ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        // Stores
 
        "STO",  0x800003f0, 0x80000270, ZIP_OPUNUSED, ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "STO",  0x802003f0, 0x80200270, ZIP_OPUNUSED, ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        // Divide based instructions
 
        "DIVU", 0x800003f0, 0x80000280, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_BITFIELD(2,19),
 
        "DIVU", 0x802003f0, 0x80200280, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
 
        "DIVU", 0x800003f0, 0x80000290, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "DIVU", 0x802003f0, 0x80200290, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        //
 
        "DIVS", 0x800003f0, 0x800002a0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_BITFIELD(2,19),
 
        "DIVS", 0x802003f0, 0x802002a0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
 
        "DIVS", 0x800003f0, 0x800002b0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "DIVS", 0x802003f0, 0x802002b0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        // LDI based instructions
 
        "CLR",  0x802003df, 0x800002c0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        "CLR",  0x802003df, 0x802002c0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        "LDI",  0x802003c0, 0x800002c0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(5,0), ZIP_OPUNUSED,
 
        "LDI",  0x802003c0, 0x802002c0, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_IMMFIELD(5,0), ZIP_BITFIELD(2,19),
 
        //
 
        "NOOP", 0x80003bf0, 0x80003b00, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        //
 
        "BRK",  0x80003bff, 0x80003b20, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        "BRK",  0x80003bf0, 0x80003b20, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
 
        //
 
        "LOCK", 0x80003bf0, 0x80003b40, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        //
 
        // FPU instructions
 
        //
 
        "FPADD",0x802003f0, 0x80000310, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        "FPADD",0x802003f0, 0x80200310, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        //
 
        "FPSUB",0x802003f0, 0x80000330, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        "FPSUB",0x802003f0, 0x80200330, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        //
 
        "FPMUL",0x802003f0, 0x80000350, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        "FPMUL",0x802003f0, 0x80200350, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        //
 
        "FPDIV",0x802003f0, 0x80000370, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        "FPDIV",0x802003f0, 0x80200370, ZIP_REGFIELD(10), ZIP_REGFIELD(10), ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        // Convert to floating point
 
        "FPCVT",0x802003f0, 0x80000380, ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_OPUNUSED,
 
        "FPCVT",0x802003f0, 0x80200380, ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(4,0), ZIP_BITFIELD(2,19),
 
        "FPCVT",0x802003f0, 0x80000390, ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        "FPCVT",0x802003f0, 0x80200390, ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        // Convert to integer
 
        "FPINT",0x802003f0, 0x800003b0, ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_OPUNUSED,
 
        "FPINT",0x802003f0, 0x802003b0, ZIP_REGFIELD(10), ZIP_OPUNUSED, ZIP_REGFIELD(0), ZIP_OPUNUSED, ZIP_BITFIELD(2,19),
 
        //
        //
        //
        //
        // Illegal instruction !!
        // Illegal instruction !!
        "ILL",  0x00000000, 0x00000000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(32,0), ZIP_OPUNUSED
        { "ILLV",       0x80000000, 0x80000000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(15,0), ZIP_OPUNUSED },
 
        { "ILL",        0x00000000, 0x00000000, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_OPUNUSED, ZIP_IMMFIELD(15,0), ZIP_OPUNUSED }
};
};
 
 
 
const ZOPCODE   *zip_oplist = zip_oplist_raw,
 
                *zip_opbottomlist = zip_opbottomlist_raw;
 
 
const int       nzoplist = (sizeof(zoplist)/sizeof(ZOPCODE));
const int       nzip_oplist = (sizeof(zip_oplist_raw)/sizeof(ZOPCODE));
const int       nzopbottom = (sizeof(zbottomlist)/sizeof(ZOPCODE));
const int       nzip_opbottom = (sizeof(zip_opbottomlist_raw)/sizeof(ZOPCODE));
 
 
static  int     getbits(const ZIPI ins, const int which) {
 
 
static inline   int
 
TWOWORD_LOAD(uint32_t one, uint32_t two) {
 
        // BREV followed by LODILO
 
        if (((one&0x87c40000)==0x02000000)&&((two&0x87c40000)==0x02400000)
 
                // Must be to the same register too, and on the same condition
 
                &&(((one^two)&0xf8380000)==0))
 
                return 1;
 
        return 0;
 
}
 
 
 
static  inline  int
 
OFFSET_PC_MOV(uint32_t ins) {
 
        // 0.xxxx.01101.ccc.0.1111.0.iiiiiiiiiiiii
 
        // 0xxx.x011.01cc.c011.110i.iiii.iiii.iiii
 
        //
 
        return ((ins & 0x87c7e000)==0x0343c000);
 
}
 
 
 
static  inline  int
 
TWOWORD_LJMP(uint32_t iword) {
 
        // LJMP a long jump instruction, for which the address of the target
 
        // is found in the next word
 
        if (iword==0x7c87c000)
 
                return 1;
 
        // Now, the CIS form ... an
 
        // Unconditional LJMP in the second half word
 
        if ((iword&0x80007fff)==0x80007cf8)
 
                return 1;
 
        return 0;
 
}
 
 
 
 
 
static  inline  int
 
TWOWORD_JSR(uint32_t iword, uint32_t nxtword) {
 
        // First word moves the return address to R0
 
        if (iword != 0x0343c001)
 
                return 0;
 
        // Second word is a BRA statement to ... anywhere
 
        // 0.1111.00010.ccc.0.iiiiiiiiiiiiiiiiii
 
        // 0111.1000.10cc.c0ii.iiii.iiii.iiii.iiii
 
        if ((nxtword&0xffc40000) == 0x78800000)
 
                return 1;
 
        return 0;
 
}
 
 
 
static  inline  int
 
THREEWORD_LJSR(uint32_t iword, uint32_t nxtword) {
 
        // First word moves the return address to R0
 
        if (iword!=0x0343c002)
 
                return 0;
 
        // Second word is an LJMP statement
 
        if (nxtword==0x7c87c000)
 
                return 1;
 
        return 0;
 
}
 
 
 
static  inline  int
 
TWOWORD_CIS_JSR(uint32_t iword) {
 
        // MOV 2(PC) | LOD (PC),PC
 
        //
 
        // 1.0000.111.1.1111.010
 
        //                      1.1111.100.1.1111.000
 
        if (iword == 0x87fafcf8)
 
                return 1;
 
        return 0;
 
}
 
 
 
static  inline  int
 
CIS_JSR(uint32_t iword __attribute__((unused)) ) {
 
        if (TWOWORD_CIS_JSR(iword))
 
                return 1;
 
        // MOV 1(PC) | MOV Rx,PC
 
        //
 
        // 1.0000.111.1.1111.001
 
        //                      1.1111.111.1.xxxx.000
 
        if ((iword&0xffffff87) == 0x87f9ff80)
 
                return 1;
 
        return 0;
 
}
 
 
 
static inline   int
 
POSSIBLE_TWOWORD_BEGINNING(uint32_t iword) {
 
        // Unconditional LJMP
 
        if (TWOWORD_LJMP(iword))
 
                return 1;
 
        // MOV 1(PC),PC
 
        if (iword == 0x0343c001)
 
                return 1;
 
        // MOV 2(PC),PC
 
        if (iword == 0x0343c002)
 
                return 1;
 
        if (CIS_JSR(iword))
 
                return 1;
 
        // The conditional LJMP is three words, which we don't handle ...
 
        // Any BREV command could be the beginning of a twoword instruction
 
        //
 
        // Of course, the point here is to determine whether we should (or need
 
        // to) read a second word from our read-memory function.  Reading a 
 
        // second word, given that the first is a BREV, isn't a problem since a
 
        // program can't end on/with a BREV instruction.
 
        //
 
        // BREV #,Rx
 
        if ((iword&0x87c40000)==0x02000000)
 
                return 1;
 
        return 0;
 
}
 
 
 
 
 
static uint32_t
 
zip_bitreverse(uint32_t v) {
 
        uint32_t r=0, b;
 
        for(b=0; b<32; b++, v>>=1)
 
                r = (r<<1)|(v&1);
 
        return r;
 
}
 
 
 
static inline   uint32_t
 
TWOWORD_VALUE(uint32_t one, uint32_t two) {
 
        return ((two&0x0ffff)|(zip_bitreverse(one&0x0ffff)));
 
}
 
 
 
static long
 
zip_sbits(const long val, const int bits) {
 
        long    r;
 
 
 
        r = val & ((1l<<bits)-1);
 
        if (r & (1l << (bits-1)))
 
                r |= (-1l << bits);
 
        return r;
 
}
 
 
 
static unsigned long
 
zip_ubits(const long val, const int bits) {
 
        unsigned long r = val & ((1l<<bits)-1);
 
        return r;
 
}
 
 
 
static  int
 
zip_getbits(const ZIPI ins, const int which)
 
{
        if (which & 0x40000000) {
        if (which & 0x40000000) {
                // printf("SBITS: %08x, %08x = %08lx\n", ins, which,
                return zip_sbits(ins>>(which & 0x03f), (which>>8)&0x03f);
                        // sbits(ins>>(which & 0x03f), (which>>8)&0x03f));
 
                return sbits(ins>>(which & 0x03f), (which>>8)&0x03f);
 
        } else { // if (which &0x03f)
        } else { // if (which &0x03f)
                return ubits(ins>>(which & 0x03f), (which>>8)&0x03f)
                return zip_ubits(ins>>(which & 0x03f), (which>>8)&0x03f)
                        + ((which>>16)&0x0ff);
                        + ((which>>16)&0x0ff);
        // } else {
 
                // fprintf(stderr, "Returning an uncoded %08x\n", which);
 
                // return which;
 
        }
        }
}
}
 
 
static  void static_zipi_to_string(const ZIPI ins, char *line, const ZOPCODE *listp) {
static  void
        for(int i=0; i<nzoplist; i++) {
zipi_to_halfstring(const uint32_t addr, const ZIPI ins, char *line, const ZOPCODE *listp) {
                if (((~zoplist[i].s_mask)&zoplist[i].s_val)!=0) {
 
 
        if (OFFSET_PC_MOV(ins)) {
 
                int     cv = zip_getbits(ins, ZIP_BITFIELD(3,19));
 
                int     dv = zip_getbits(ins, ZIP_REGFIELD(27));
 
                int     iv = zip_sbits(ins, 13);
 
                uint32_t        ref;
 
 
 
                ref = (iv<<2) + addr + 4;
 
 
 
                sprintf(line, "%s%s", "MOV", zip_ccstr[cv]);
 
                sprintf(line, "%-11s", line);
 
                sprintf(line, "%s0x%08x", line, ref);
 
                sprintf(line, "%s,%s", line, zip_regstr[dv]);
 
 
 
                return;
 
        } else if (TWOWORD_CIS_JSR(ins)) {
 
                sprintf(line, "%-11s", "LJSR");
 
                return;
 
        } else if (CIS_JSR(ins)) {
 
                int ra = zip_getbits(ins, ZIP_REGFIELD(3));
 
                sprintf(line, "%-11s%s", "JSR", zip_regstr[ra]);
 
                return;
 
        }
 
 
 
        int     i;
 
        for(i=0; i<nzip_oplist; i++) {
 
                if (((~zip_oplist[i].s_mask)&zip_oplist[i].s_val)!=0) {
                        printf("Instruction %d, %s, fails consistency check\n",
                        printf("Instruction %d, %s, fails consistency check\n",
                                i, zoplist[i].s_opstr);
                                i, zip_oplist[i].s_opstr);
                        assert(((~zoplist[i].s_mask)&zoplist[i].s_val)==0);
                        printf("%08x & %08x = %08x != %08x\n",
 
                                zip_oplist[i].s_mask,
 
                                zip_oplist[i].s_val,
 
                                (~zip_oplist[i].s_mask)&zip_oplist[i].s_val,
 
                                0);
 
                        assert(((~zip_oplist[i].s_mask)&zip_oplist[i].s_val)==0);
                }
                }
        } line[0] = '\0';
        } line[0] = '\0';
        for(int i=0; (listp[i].s_mask != 0); i++) {
        for(i=0; (listp[i].s_mask != 0); i++) {
                // printf("%2d: %6s %08x & %08x == %08x\n",
                // printf("%2d: %6s %08x & %08x == %08x\n",
                        // i, zoplist[i].s_opstr, ins,
                        // i, zip_oplist[i].s_opstr, ins,
                        // zoplist[i].s_mask, zoplist[i].s_val);
                        // zip_oplist[i].s_mask, zip_oplist[i].s_val);
                if ((ins & listp[i].s_mask) == listp[i].s_val) {
                if ((ins & listp[i].s_mask) == listp[i].s_val) {
 
                        // Write the opcode onto our line
                        sprintf(line, "%s", listp[i].s_opstr);
                        sprintf(line, "%s", listp[i].s_opstr);
                        if (listp[i].s_cf != ZIP_OPUNUSED) {
                        if (listp[i].s_cf != ZIP_OPUNUSED) {
                                int bv = getbits(ins, listp[i].s_cf);
                                int bv = zip_getbits(ins, listp[i].s_cf);
                                strcat(line, zop_ccstr[bv]);
                                strcat(line, zip_ccstr[bv]);
                        } sprintf(line, "%-11s", line);
                        } sprintf(line, "%-11s", line); // Pad it to 11 chars
 
 
 
                        int     ra = -1, rb = -1, rr = -1, imv = 0;
 
 
 
                        if (listp[i].s_result != ZIP_OPUNUSED)
 
                                rr = zip_getbits(ins, listp[i].s_result);
 
                        if (listp[i].s_ra != ZIP_OPUNUSED)
 
                                ra = zip_getbits(ins, listp[i].s_ra);
 
                        if (listp[i].s_rb != ZIP_OPUNUSED)
 
                                rb = zip_getbits(ins, listp[i].s_rb);
 
                        if (listp[i].s_i != ZIP_OPUNUSED)
 
                                imv = zip_getbits(ins, listp[i].s_i);
 
 
 
                        if ((listp[i].s_rb != ZIP_OPUNUSED)&&(rb == 15))
 
                                imv <<= 2;
 
 
                        // Treat stores special
                        // Treat stores special
                        if (strncasecmp("STO",listp[i].s_opstr, 3)==0) {
                        if ((strncasecmp("SW",listp[i].s_opstr, 2)==0)
                                int ra = getbits(ins, listp[i].s_ra);
                                ||(strncasecmp("SH",listp[i].s_opstr, 2)==0)
                                strcat(line, zop_regstr[ra]);
                                ||(strncasecmp("SB",listp[i].s_opstr, 2)==0)) {
 
                                strcat(line, zip_regstr[ra]);
                                strcat(line, ",");
                                strcat(line, ",");
 
 
                                if (listp[i].s_i != ZIP_OPUNUSED) {
                                if (listp[i].s_i != ZIP_OPUNUSED) {
                                        int     imv = 0;
                                        if (listp[i].s_rb == ZIP_OPUNUSED)
                                        imv = getbits(ins, listp[i].s_i);
 
                                        if ((imv != 0)&&(listp[i].s_rb != ZIP_OPUNUSED))
 
                                                sprintf(&line[strlen(line)],
                                                sprintf(&line[strlen(line)],
                                                        "$%d", imv);
                                                        "($%d)", imv);
                                        else if (imv != 0)
                                        else if (imv != 0)
                                                sprintf(&line[strlen(line)],
                                                sprintf(&line[strlen(line)],
                                                        "($%d)", imv);
                                                        "$%d", imv);
                                } if (listp[i].s_rb != ZIP_OPUNUSED) {
                                } if (listp[i].s_rb != ZIP_OPUNUSED) {
                                        int rb = getbits(ins, listp[i].s_rb);
 
                                        sprintf(&line[strlen(line)],
                                        sprintf(&line[strlen(line)],
                                                "(%s)", zop_regstr[rb]);
                                                "(%s)", zip_regstr[rb]);
                                }
                                }
 
                        // Treat long jumps special
 
                        } else if (strncasecmp("LJMP",listp[i].s_opstr, 3)==0) {
 
                        // Treat relative jumps (branches) specially as well
 
                        } else if ((toupper(listp[i].s_opstr[0]=='B'))
 
                                &&(strcasecmp(listp[i].s_opstr,"BUSY")!=0)
 
                                &&(strcasecmp(listp[i].s_opstr,"BREV")!=0)
 
                                &&(strcasecmp(listp[i].s_opstr,"BRK")!=0)
 
                                &&(addr != 0)) {
 
                                // Branch instruction: starts with B and isn't
 
                                // BREV (bit reverse), BRK (break), or 
 
                                // BUSY
 
                                uint32_t target = addr;
 
 
 
                                target += zip_getbits(ins, listp[i].s_i)+4;
 
                                sprintf(&line[strlen(line)], "@0x%08x", target);
                        } else {
                        } else {
                                bool memop = (strncasecmp("LOD",
                                int memop = 0;
                                                listp[i].s_opstr, 3)==0);
                                if (('L'==toupper(listp[i].s_opstr[0]))
                                if (listp[i].s_i != ZIP_OPUNUSED) {
                                        &&(('W'==toupper(listp[i].s_opstr[1]))
                                        int     imv = 0;
                                         ||('H'==toupper(listp[i].s_opstr[1]))
 
                                         ||('B'==toupper(listp[i].s_opstr[1])))
 
                                        &&(!listp[i].s_opstr[2]))
 
                                        memop = 1;
 
 
                                        imv = getbits(ins, listp[i].s_i);
                                if (listp[i].s_i != ZIP_OPUNUSED) {
                                        if ((imv != 0)||(listp[i].s_rb == ZIP_OPUNUSED))
                                        if((memop)&&(listp[i].s_rb == ZIP_OPUNUSED))
 
                                                sprintf(&line[strlen(line)],
 
                                                        "($%d)", imv);
 
                                        else if((memop)&&(imv != 0))
 
                                                sprintf(&line[strlen(line)],
 
                                                        "%d", imv);
 
                                        else if((!memop)&&((imv != 0)||(listp[i].s_rb == ZIP_OPUNUSED)))
                                                sprintf(&line[strlen(line)],
                                                sprintf(&line[strlen(line)],
                                                        "$%d%s", imv,
                                                        "$%d%s", imv,
                                                        ((!memop)&&(listp[i].s_rb!=ZIP_OPUNUSED))?"+":"");
                                                        (listp[i].s_rb!=ZIP_OPUNUSED)?"+":"");
                                } if (listp[i].s_rb != ZIP_OPUNUSED) {
                                } if (listp[i].s_rb != ZIP_OPUNUSED) {
                                        int rb = getbits(ins, listp[i].s_rb);
 
                                        if (memop)
                                        if (memop)
                                                sprintf(&line[strlen(line)],
                                                sprintf(&line[strlen(line)],
                                                        "(%s)", zop_regstr[rb]);
                                                        "(%s)", zip_regstr[rb]);
                                        else
                                        else
                                                strcat(line, zop_regstr[rb]);
                                                strcat(line, zip_regstr[rb]);
                                } if(((listp[i].s_i != ZIP_OPUNUSED)||(listp[i].s_rb != ZIP_OPUNUSED))
                                } if(((listp[i].s_i != ZIP_OPUNUSED)||(listp[i].s_rb != ZIP_OPUNUSED))
                                        &&((listp[i].s_ra != ZIP_OPUNUSED)||(listp[i].s_result != ZIP_OPUNUSED)))
                                        &&((listp[i].s_ra != ZIP_OPUNUSED)||(listp[i].s_result != ZIP_OPUNUSED)))
                                        strcat(line, ",");
                                        strcat(line, ",");
 
 
                                if (listp[i].s_ra != ZIP_OPUNUSED) {
                                if (listp[i].s_ra != ZIP_OPUNUSED) {
                                        int ra = getbits(ins, listp[i].s_ra);
                                        strcat(line, zip_regstr[ra]);
                                        strcat(line, zop_regstr[ra]);
 
                                } else if (listp[i].s_result != ZIP_OPUNUSED) {
                                } else if (listp[i].s_result != ZIP_OPUNUSED) {
                                        int ra = getbits(ins, listp[i].s_result);
                                        strcat(line, zip_regstr[rr]);
                                        strcat(line, zop_regstr[ra]);
 
                                }
                                }
 
 
                        }
                        }
                        break;
                        break;
                }
                }
        } if (line[0] == '\0') {
        } if (line[0] == '\0') {
                sprintf(line, "ILL %08x", ins);
                sprintf(line, "ILL %08x", ins);
        }
        }
}
}
 
 
void    zipi_to_string(const ZIPI ins, char *la, char *lb) {
void
        static_zipi_to_string(ins, la, zoplist);
zipi_to_double_string(const uint32_t addr, const ZIPI ins, char *la, char *lb) {
 
        zipi_to_halfstring(addr, ins, la, zip_oplist);
        if (lb) {
        if (lb) {
                if (ins & 0x80000000) {
                if ((ins & 0x80000000)&&(!CIS_JSR(ins))) {
                        static_zipi_to_string(ins, lb, zbottomlist);
                        zipi_to_halfstring(addr, ins, lb, zip_opbottomlist);
                } else lb[0] = '\0';
                } else lb[0] = '\0';
        }
        }
}
}
 
 
unsigned int    zop_early_branch(const unsigned int pc, const ZIPI ins) {
unsigned int    zop_early_branch(const unsigned int pc, const ZIPI insn) {
        if ((ins & 0xf8000000) != 0x78000000)
        if ((insn & 0xf8000000) != 0x78000000)
                return pc+1;
                return pc+4;
        if ((ins & 0x07c00000) == 0x05800000) // LDI, high bit clear
        if ((insn & 0xffc60000) == 0x78800000)  // BRA high bit clear
                return (ins & 0x003fffff);
                return (pc + 4 + ((insn & 0x3ffff)<<2));
        if ((ins & 0x07c00000) == 0x05c00000) // LDI, high bit set
        if ((insn & 0xffc60000) == 0x78820000)  // BRA high bit set (negative)
                return (ins & 0x007fffff)|0xffc00000;
                return (pc + 4 + ((0x40000 - (insn & 0x3ffff))<<2));
        // if ((ins & 0xffffe000) == 0x7bc3c000) // MOV
        return pc+4;
                // return ((ins & 0x001fff)|((ins&0x01000)?0xffffe000:0))+pc+1;
 
        if ((ins & 0x07fc0000) == 0x00800000) // ADD, unconditional
 
                return ((ins & 0x03ffff)|((ins&0x020000)?0xfffc0000:0))+pc+1;
 
        return pc+1;
 
}
}
 
 
 
 
 
 
 No newline at end of file
 No newline at end of file

powered by: WebSVN 2.1.0

© copyright 1999-2022 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.