[mirror_qemu.git] / disas / moxie.c

/* Disassemble moxie instructions.
   Copyright (c) 2009  Free Software Foundation, Inc.

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

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

   You should have received a copy of the GNU General Public License
   along with this program; if not, see <http://www.gnu.org/licenses/>. */

#include <stdio.h>
#define STATIC_TABLE
#define DEFINE_TABLE

#include "disas/bfd.h"

static void *stream;

/* Form 1 instructions come in different flavors:

   Some have no arguments                          (MOXIE_F1_NARG)
   Some only use the A operand                     (MOXIE_F1_A)
   Some use A and B registers                      (MOXIE_F1_AB)
   Some use A and consume a 4 byte immediate value (MOXIE_F1_A4)
   Some use just a 4 byte immediate value          (MOXIE_F1_4)
   Some use just a 4 byte memory address           (MOXIE_F1_M)
   Some use B and an indirect A                    (MOXIE_F1_AiB)
   Some use A and an indirect B                    (MOXIE_F1_ABi)
   Some consume a 4 byte immediate value and use X (MOXIE_F1_4A)
   Some use B and an indirect A plus 4 bytes       (MOXIE_F1_AiB4)
   Some use A and an indirect B plus 4 bytes       (MOXIE_F1_ABi4)

   Form 2 instructions also come in different flavors:

   Some have no arguments                          (MOXIE_F2_NARG)
   Some use the A register and an 8-bit value      (MOXIE_F2_A8V)

   Form 3 instructions also come in different flavors:

   Some have no arguments                          (MOXIE_F3_NARG)
   Some have a 10-bit PC relative operand          (MOXIE_F3_PCREL).  */

#define MOXIE_F1_NARG 0x100
#define MOXIE_F1_A    0x101
#define MOXIE_F1_AB   0x102
/* #define MOXIE_F1_ABC  0x103 */
#define MOXIE_F1_A4   0x104
#define MOXIE_F1_4    0x105
#define MOXIE_F1_AiB  0x106
#define MOXIE_F1_ABi  0x107
#define MOXIE_F1_4A   0x108
#define MOXIE_F1_AiB4 0x109
#define MOXIE_F1_ABi4 0x10a
#define MOXIE_F1_M    0x10b

#define MOXIE_F2_NARG 0x200
#define MOXIE_F2_A8V  0x201

#define MOXIE_F3_NARG  0x300
#define MOXIE_F3_PCREL 0x301

typedef struct moxie_opc_info_t {
    short         opcode;
    unsigned      itype;
    const char *  name;
} moxie_opc_info_t;

extern const moxie_opc_info_t moxie_form1_opc_info[64];
extern const moxie_opc_info_t moxie_form2_opc_info[4];
extern const moxie_opc_info_t moxie_form3_opc_info[16];

/* The moxie processor's 16-bit instructions come in two forms:

   FORM 1 instructions start with a 0 bit...

   0oooooooaaaabbbb
   0              F

   ooooooo - form 1 opcode number
   aaaa    - operand A
   bbbb    - operand B

   FORM 2 instructions start with bits "10"...

   10ooaaaavvvvvvvv
   0              F

   oo       - form 2 opcode number
   aaaa     - operand A
   vvvvvvvv - 8-bit immediate value

   FORM 3 instructions start with a bits "11"...

   11oooovvvvvvvvvv
   0              F

   oooo         - form 3 opcode number
   vvvvvvvvvv   - 10-bit immediate value.  */

const moxie_opc_info_t moxie_form1_opc_info[64] =
    {
        { 0x00, MOXIE_F1_NARG, "nop" },
        { 0x01, MOXIE_F1_A4,   "ldi.l" },
        { 0x02, MOXIE_F1_AB,   "mov" },
        { 0x03, MOXIE_F1_M,    "jsra" },
        { 0x04, MOXIE_F1_NARG, "ret" },
        { 0x05, MOXIE_F1_AB,   "add.l" },
        { 0x06, MOXIE_F1_AB,   "push" },
        { 0x07, MOXIE_F1_AB,   "pop" },
        { 0x08, MOXIE_F1_A4,   "lda.l" },
        { 0x09, MOXIE_F1_4A,   "sta.l" },
        { 0x0a, MOXIE_F1_ABi,  "ld.l" },
        { 0x0b, MOXIE_F1_AiB,  "st.l" },
        { 0x0c, MOXIE_F1_ABi4, "ldo.l" },
        { 0x0d, MOXIE_F1_AiB4, "sto.l" },
        { 0x0e, MOXIE_F1_AB,   "cmp" },
        { 0x0f, MOXIE_F1_NARG, "bad" },
        { 0x10, MOXIE_F1_NARG, "bad" },
        { 0x11, MOXIE_F1_NARG, "bad" },
        { 0x12, MOXIE_F1_NARG, "bad" },
        { 0x13, MOXIE_F1_NARG, "bad" },
        { 0x14, MOXIE_F1_NARG, "bad" },
        { 0x15, MOXIE_F1_NARG, "bad" },
        { 0x16, MOXIE_F1_NARG, "bad" },
        { 0x17, MOXIE_F1_NARG, "bad" },
        { 0x18, MOXIE_F1_NARG, "bad" },
        { 0x19, MOXIE_F1_A,    "jsr" },
        { 0x1a, MOXIE_F1_M,    "jmpa" },
        { 0x1b, MOXIE_F1_A4,   "ldi.b" },
        { 0x1c, MOXIE_F1_ABi,  "ld.b" },
        { 0x1d, MOXIE_F1_A4,   "lda.b" },
        { 0x1e, MOXIE_F1_AiB,  "st.b" },
        { 0x1f, MOXIE_F1_4A,   "sta.b" },
        { 0x20, MOXIE_F1_A4,   "ldi.s" },
        { 0x21, MOXIE_F1_ABi,  "ld.s" },
        { 0x22, MOXIE_F1_A4,   "lda.s" },
        { 0x23, MOXIE_F1_AiB,  "st.s" },
        { 0x24, MOXIE_F1_4A,   "sta.s" },
        { 0x25, MOXIE_F1_A,    "jmp" },
        { 0x26, MOXIE_F1_AB,   "and" },
        { 0x27, MOXIE_F1_AB,   "lshr" },
        { 0x28, MOXIE_F1_AB,   "ashl" },
        { 0x29, MOXIE_F1_AB,   "sub.l" },
        { 0x2a, MOXIE_F1_AB,   "neg" },
        { 0x2b, MOXIE_F1_AB,   "or" },
        { 0x2c, MOXIE_F1_AB,   "not" },
        { 0x2d, MOXIE_F1_AB,   "ashr" },
        { 0x2e, MOXIE_F1_AB,   "xor" },
        { 0x2f, MOXIE_F1_AB,   "mul.l" },
        { 0x30, MOXIE_F1_4,    "swi" },
        { 0x31, MOXIE_F1_AB,   "div.l" },
        { 0x32, MOXIE_F1_AB,   "udiv.l" },
        { 0x33, MOXIE_F1_AB,   "mod.l" },
        { 0x34, MOXIE_F1_AB,   "umod.l" },
        { 0x35, MOXIE_F1_NARG, "brk" },
        { 0x36, MOXIE_F1_ABi4, "ldo.b" },
        { 0x37, MOXIE_F1_AiB4, "sto.b" },
        { 0x38, MOXIE_F1_ABi4, "ldo.s" },
        { 0x39, MOXIE_F1_AiB4, "sto.s" },
        { 0x3a, MOXIE_F1_NARG, "bad" },
        { 0x3b, MOXIE_F1_NARG, "bad" },
        { 0x3c, MOXIE_F1_NARG, "bad" },
        { 0x3d, MOXIE_F1_NARG, "bad" },
        { 0x3e, MOXIE_F1_NARG, "bad" },
        { 0x3f, MOXIE_F1_NARG, "bad" }
    };

const moxie_opc_info_t moxie_form2_opc_info[4] =
    {
        { 0x00, MOXIE_F2_A8V,  "inc" },
        { 0x01, MOXIE_F2_A8V,  "dec" },
        { 0x02, MOXIE_F2_A8V,  "gsr" },
        { 0x03, MOXIE_F2_A8V,  "ssr" }
    };

const moxie_opc_info_t moxie_form3_opc_info[16] =
    {
        { 0x00, MOXIE_F3_PCREL,"beq" },
        { 0x01, MOXIE_F3_PCREL,"bne" },
        { 0x02, MOXIE_F3_PCREL,"blt" },
        { 0x03, MOXIE_F3_PCREL,"bgt" },
        { 0x04, MOXIE_F3_PCREL,"bltu" },
        { 0x05, MOXIE_F3_PCREL,"bgtu" },
        { 0x06, MOXIE_F3_PCREL,"bge" },
        { 0x07, MOXIE_F3_PCREL,"ble" },
        { 0x08, MOXIE_F3_PCREL,"bgeu" },
        { 0x09, MOXIE_F3_PCREL,"bleu" },
        { 0x0a, MOXIE_F3_NARG, "bad" },
        { 0x0b, MOXIE_F3_NARG, "bad" },
        { 0x0c, MOXIE_F3_NARG, "bad" },
        { 0x0d, MOXIE_F3_NARG, "bad" },
        { 0x0e, MOXIE_F3_NARG, "bad" },
        { 0x0f, MOXIE_F3_NARG, "bad" }
    };

/* Macros to extract operands from the instruction word.  */
#define OP_A(i) ((i >> 4) & 0xf)
#define OP_B(i) (i & 0xf)
#define INST2OFFSET(o) ((((signed short)((o & ((1<<10)-1))<<6))>>6)<<1)

static const char * reg_names[16] =
    { "$fp", "$sp", "$r0", "$r1", "$r2", "$r3", "$r4", "$r5",
      "$r6", "$r7", "$r8", "$r9", "$r10", "$r11", "$r12", "$r13" };

int
print_insn_moxie(bfd_vma addr, struct disassemble_info * info)
{
    int length = 2;
    int status;
    stream = info->stream;
    const moxie_opc_info_t * opcode;
    bfd_byte buffer[4];
    unsigned short iword;
    fprintf_function fpr = info->fprintf_func;

    if ((status = info->read_memory_func(addr, buffer, 2, info)))
        goto fail;
    iword = (bfd_getb16(buffer) >> 16);

    /* Form 1 instructions have the high bit set to 0.  */
    if ((iword & (1<<15)) == 0) {
        /* Extract the Form 1 opcode.  */
        opcode = &moxie_form1_opc_info[iword >> 8];
        switch (opcode->itype) {
        case MOXIE_F1_NARG:
            fpr(stream, "%s", opcode->name);
            break;
        case MOXIE_F1_A:
            fpr(stream, "%s\t%s", opcode->name,
                reg_names[OP_A(iword)]);
            break;
        case MOXIE_F1_AB:
            fpr(stream, "%s\t%s, %s", opcode->name,
                reg_names[OP_A(iword)],
                reg_names[OP_B(iword)]);
            break;
        case MOXIE_F1_A4:
            {
                unsigned imm;
                if ((status = info->read_memory_func(addr + 2, buffer, 4, info)))
                    goto fail;
                imm = bfd_getb32(buffer);
                fpr(stream, "%s\t%s, 0x%x", opcode->name,
                    reg_names[OP_A(iword)], imm);
                length = 6;
            }
            break;
        case MOXIE_F1_4:
            {
                unsigned imm;
                if ((status = info->read_memory_func(addr + 2, buffer, 4, info)))
                    goto fail;
                imm = bfd_getb32(buffer);
                fpr(stream, "%s\t0x%x", opcode->name, imm);
                length = 6;
            }
            break;
        case MOXIE_F1_M:
            {
                unsigned imm;
                if ((status = info->read_memory_func(addr + 2, buffer, 4, info)))
                    goto fail;
                imm = bfd_getb32(buffer);
                fpr(stream, "%s\t", opcode->name);
                info->print_address_func((bfd_vma) imm, info);
                length = 6;
            }
            break;
        case MOXIE_F1_AiB:
            fpr (stream, "%s\t(%s), %s", opcode->name,
                 reg_names[OP_A(iword)], reg_names[OP_B(iword)]);
            break;
        case MOXIE_F1_ABi:
            fpr(stream, "%s\t%s, (%s)", opcode->name,
                reg_names[OP_A(iword)], reg_names[OP_B(iword)]);
            break;
        case MOXIE_F1_4A:
            {
                unsigned imm;
                if ((status = info->read_memory_func(addr + 2, buffer, 4, info)))
                    goto fail;
                imm = bfd_getb32(buffer);
                fpr(stream, "%s\t0x%x, %s",
                    opcode->name, imm, reg_names[OP_A(iword)]);
                length = 6;
            }
            break;
        case MOXIE_F1_AiB4:
            {
                unsigned imm;
                if ((status = info->read_memory_func(addr+2, buffer, 4, info)))
                    goto fail;
                imm = bfd_getb32(buffer);
                fpr(stream, "%s\t0x%x(%s), %s", opcode->name,
                    imm,
                    reg_names[OP_A(iword)],
                    reg_names[OP_B(iword)]);
                length = 6;
            }
            break;
        case MOXIE_F1_ABi4:
            {
                unsigned imm;
                if ((status = info->read_memory_func(addr+2, buffer, 4, info)))
                    goto fail;
                imm = bfd_getb32(buffer);
                fpr(stream, "%s\t%s, 0x%x(%s)",
                    opcode->name,
                    reg_names[OP_A(iword)],
                    imm,
                    reg_names[OP_B(iword)]);
                length = 6;
            }
            break;
        default:
            abort();
        }
    }
    else if ((iword & (1<<14)) == 0) {
        /* Extract the Form 2 opcode.  */
        opcode = &moxie_form2_opc_info[(iword >> 12) & 3];
        switch (opcode->itype) {
        case MOXIE_F2_A8V:
            fpr(stream, "%s\t%s, 0x%x",
                opcode->name,
                reg_names[(iword >> 8) & 0xf],
                iword & ((1 << 8) - 1));
            break;
        case MOXIE_F2_NARG:
            fpr(stream, "%s", opcode->name);
            break;
        default:
            abort();
        }
    } else {
        /* Extract the Form 3 opcode.  */
        opcode = &moxie_form3_opc_info[(iword >> 10) & 15];
        switch (opcode->itype) {
        case MOXIE_F3_PCREL:
            fpr(stream, "%s\t", opcode->name);
            info->print_address_func((bfd_vma) (addr + INST2OFFSET(iword) + 2),
                                     info);
            break;
        default:
            abort();
        }
    }

    return length;

 fail:
    info->memory_error_func(status, addr, info);
    return -1;
}
Commit	Line	Data
bd86a88e AG	1	/* Disassemble moxie instructions.
	2	Copyright (c) 2009 Free Software Foundation, Inc.
	3
	4	This program is free software; you can redistribute it and/or modify
	5	it under the terms of the GNU General Public License as published by
	6	the Free Software Foundation; either version 2 of the License, or
	7	(at your option) any later version.
	8
	9	This program is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	GNU General Public License for more details.
	13
	14	You should have received a copy of the GNU General Public License
	15	along with this program; if not, see <http://www.gnu.org/licenses/>. */
	16
	17	#include <stdio.h>
	18	#define STATIC_TABLE
	19	#define DEFINE_TABLE
	20
	21	#include "disas/bfd.h"
	22
	23	static void *stream;
	24
	25	/* Form 1 instructions come in different flavors:
	26
	27	Some have no arguments (MOXIE_F1_NARG)
	28	Some only use the A operand (MOXIE_F1_A)
	29	Some use A and B registers (MOXIE_F1_AB)
	30	Some use A and consume a 4 byte immediate value (MOXIE_F1_A4)
	31	Some use just a 4 byte immediate value (MOXIE_F1_4)
	32	Some use just a 4 byte memory address (MOXIE_F1_M)
	33	Some use B and an indirect A (MOXIE_F1_AiB)
	34	Some use A and an indirect B (MOXIE_F1_ABi)
	35	Some consume a 4 byte immediate value and use X (MOXIE_F1_4A)
	36	Some use B and an indirect A plus 4 bytes (MOXIE_F1_AiB4)
	37	Some use A and an indirect B plus 4 bytes (MOXIE_F1_ABi4)
	38
	39	Form 2 instructions also come in different flavors:
	40
	41	Some have no arguments (MOXIE_F2_NARG)
	42	Some use the A register and an 8-bit value (MOXIE_F2_A8V)
	43
	44	Form 3 instructions also come in different flavors:
	45
	46	Some have no arguments (MOXIE_F3_NARG)
	47	Some have a 10-bit PC relative operand (MOXIE_F3_PCREL). */
	48
	49	#define MOXIE_F1_NARG 0x100
	50	#define MOXIE_F1_A 0x101
	51	#define MOXIE_F1_AB 0x102
	52	/* #define MOXIE_F1_ABC 0x103 */
	53	#define MOXIE_F1_A4 0x104
	54	#define MOXIE_F1_4 0x105
	55	#define MOXIE_F1_AiB 0x106
	56	#define MOXIE_F1_ABi 0x107
	57	#define MOXIE_F1_4A 0x108
	58	#define MOXIE_F1_AiB4 0x109
	59	#define MOXIE_F1_ABi4 0x10a
	60	#define MOXIE_F1_M 0x10b
	61
	62	#define MOXIE_F2_NARG 0x200
	63	#define MOXIE_F2_A8V 0x201
	64
65	#define MOXIE_F3_NARG 0x300
66	#define MOXIE_F3_PCREL 0x301
67
68	typedef struct moxie_opc_info_t {
69	short opcode;
70	unsigned itype;
71	const char * name;
72	} moxie_opc_info_t;
73
74	extern const moxie_opc_info_t moxie_form1_opc_info[64];
75	extern const moxie_opc_info_t moxie_form2_opc_info[4];
76	extern const moxie_opc_info_t moxie_form3_opc_info[16];
77
78	/* The moxie processor's 16-bit instructions come in two forms:
79
80	FORM 1 instructions start with a 0 bit...
81
82	0oooooooaaaabbbb
83	0 F
84
85	ooooooo - form 1 opcode number
86	aaaa - operand A
87	bbbb - operand B
88
89	FORM 2 instructions start with bits "10"...
90
91	10ooaaaavvvvvvvv
92	0 F
93
94	oo - form 2 opcode number
95	aaaa - operand A
96	vvvvvvvv - 8-bit immediate value
97
98	FORM 3 instructions start with a bits "11"...
99
100	11oooovvvvvvvvvv
101	0 F
102
103	oooo - form 3 opcode number
104	vvvvvvvvvv - 10-bit immediate value. */
105
106	const moxie_opc_info_t moxie_form1_opc_info[64] =
107	{
108	{ 0x00, MOXIE_F1_NARG, "nop" },
109	{ 0x01, MOXIE_F1_A4, "ldi.l" },
110	{ 0x02, MOXIE_F1_AB, "mov" },
111	{ 0x03, MOXIE_F1_M, "jsra" },
112	{ 0x04, MOXIE_F1_NARG, "ret" },
113	{ 0x05, MOXIE_F1_AB, "add.l" },
114	{ 0x06, MOXIE_F1_AB, "push" },
115	{ 0x07, MOXIE_F1_AB, "pop" },
116	{ 0x08, MOXIE_F1_A4, "lda.l" },
117	{ 0x09, MOXIE_F1_4A, "sta.l" },
118	{ 0x0a, MOXIE_F1_ABi, "ld.l" },
119	{ 0x0b, MOXIE_F1_AiB, "st.l" },
120	{ 0x0c, MOXIE_F1_ABi4, "ldo.l" },
121	{ 0x0d, MOXIE_F1_AiB4, "sto.l" },
122	{ 0x0e, MOXIE_F1_AB, "cmp" },
123	{ 0x0f, MOXIE_F1_NARG, "bad" },
124	{ 0x10, MOXIE_F1_NARG, "bad" },
125	{ 0x11, MOXIE_F1_NARG, "bad" },
126	{ 0x12, MOXIE_F1_NARG, "bad" },
127	{ 0x13, MOXIE_F1_NARG, "bad" },
128	{ 0x14, MOXIE_F1_NARG, "bad" },
129	{ 0x15, MOXIE_F1_NARG, "bad" },
130	{ 0x16, MOXIE_F1_NARG, "bad" },
131	{ 0x17, MOXIE_F1_NARG, "bad" },
132	{ 0x18, MOXIE_F1_NARG, "bad" },
133	{ 0x19, MOXIE_F1_A, "jsr" },
134	{ 0x1a, MOXIE_F1_M, "jmpa" },
135	{ 0x1b, MOXIE_F1_A4, "ldi.b" },
136	{ 0x1c, MOXIE_F1_ABi, "ld.b" },
137	{ 0x1d, MOXIE_F1_A4, "lda.b" },
138	{ 0x1e, MOXIE_F1_AiB, "st.b" },
139	{ 0x1f, MOXIE_F1_4A, "sta.b" },
140	{ 0x20, MOXIE_F1_A4, "ldi.s" },
141	{ 0x21, MOXIE_F1_ABi, "ld.s" },
142	{ 0x22, MOXIE_F1_A4, "lda.s" },
143	{ 0x23, MOXIE_F1_AiB, "st.s" },
144	{ 0x24, MOXIE_F1_4A, "sta.s" },
145	{ 0x25, MOXIE_F1_A, "jmp" },
146	{ 0x26, MOXIE_F1_AB, "and" },
147	{ 0x27, MOXIE_F1_AB, "lshr" },
148	{ 0x28, MOXIE_F1_AB, "ashl" },
149	{ 0x29, MOXIE_F1_AB, "sub.l" },
150	{ 0x2a, MOXIE_F1_AB, "neg" },
151	{ 0x2b, MOXIE_F1_AB, "or" },
152	{ 0x2c, MOXIE_F1_AB, "not" },
153	{ 0x2d, MOXIE_F1_AB, "ashr" },
154	{ 0x2e, MOXIE_F1_AB, "xor" },
155	{ 0x2f, MOXIE_F1_AB, "mul.l" },
156	{ 0x30, MOXIE_F1_4, "swi" },
157	{ 0x31, MOXIE_F1_AB, "div.l" },
158	{ 0x32, MOXIE_F1_AB, "udiv.l" },
159	{ 0x33, MOXIE_F1_AB, "mod.l" },
160	{ 0x34, MOXIE_F1_AB, "umod.l" },
161	{ 0x35, MOXIE_F1_NARG, "brk" },
162	{ 0x36, MOXIE_F1_ABi4, "ldo.b" },
163	{ 0x37, MOXIE_F1_AiB4, "sto.b" },
164	{ 0x38, MOXIE_F1_ABi4, "ldo.s" },
165	{ 0x39, MOXIE_F1_AiB4, "sto.s" },
166	{ 0x3a, MOXIE_F1_NARG, "bad" },
167	{ 0x3b, MOXIE_F1_NARG, "bad" },
168	{ 0x3c, MOXIE_F1_NARG, "bad" },
169	{ 0x3d, MOXIE_F1_NARG, "bad" },
170	{ 0x3e, MOXIE_F1_NARG, "bad" },
171	{ 0x3f, MOXIE_F1_NARG, "bad" }
172	};
173
174	const moxie_opc_info_t moxie_form2_opc_info[4] =
175	{
176	{ 0x00, MOXIE_F2_A8V, "inc" },
177	{ 0x01, MOXIE_F2_A8V, "dec" },
178	{ 0x02, MOXIE_F2_A8V, "gsr" },
179	{ 0x03, MOXIE_F2_A8V, "ssr" }
180	};
181
182	const moxie_opc_info_t moxie_form3_opc_info[16] =
183	{
184	{ 0x00, MOXIE_F3_PCREL,"beq" },
185	{ 0x01, MOXIE_F3_PCREL,"bne" },
186	{ 0x02, MOXIE_F3_PCREL,"blt" },
187	{ 0x03, MOXIE_F3_PCREL,"bgt" },
188	{ 0x04, MOXIE_F3_PCREL,"bltu" },
189	{ 0x05, MOXIE_F3_PCREL,"bgtu" },
190	{ 0x06, MOXIE_F3_PCREL,"bge" },
191	{ 0x07, MOXIE_F3_PCREL,"ble" },
192	{ 0x08, MOXIE_F3_PCREL,"bgeu" },
193	{ 0x09, MOXIE_F3_PCREL,"bleu" },
194	{ 0x0a, MOXIE_F3_NARG, "bad" },
195	{ 0x0b, MOXIE_F3_NARG, "bad" },
196	{ 0x0c, MOXIE_F3_NARG, "bad" },
197	{ 0x0d, MOXIE_F3_NARG, "bad" },
198	{ 0x0e, MOXIE_F3_NARG, "bad" },
199	{ 0x0f, MOXIE_F3_NARG, "bad" }
200	};
201
202	/* Macros to extract operands from the instruction word. */
203	#define OP_A(i) ((i >> 4) & 0xf)
204	#define OP_B(i) (i & 0xf)
205	#define INST2OFFSET(o) ((((signed short)((o & ((1<<10)-1))<<6))>>6)<<1)
206
207	static const char * reg_names[16] =
208	{ "$fp", "$sp", "$r0", "$r1", "$r2", "$r3", "$r4", "$r5",
209	"$r6", "$r7", "$r8", "$r9", "$r10", "$r11", "$r12", "$r13" };
210
211	int
212	print_insn_moxie(bfd_vma addr, struct disassemble_info * info)
213	{
214	int length = 2;
215	int status;
216	stream = info->stream;
217	const moxie_opc_info_t * opcode;
218	bfd_byte buffer[4];
219	unsigned short iword;
220	fprintf_function fpr = info->fprintf_func;
221
222	if ((status = info->read_memory_func(addr, buffer, 2, info)))
223	goto fail;
224	iword = (bfd_getb16(buffer) >> 16);
225
226	/* Form 1 instructions have the high bit set to 0. */
227	if ((iword & (1<<15)) == 0) {
228	/* Extract the Form 1 opcode. */
229	opcode = &moxie_form1_opc_info[iword >> 8];
230	switch (opcode->itype) {
231	case MOXIE_F1_NARG:
232	fpr(stream, "%s", opcode->name);
233	break;
234	case MOXIE_F1_A:
235	fpr(stream, "%s\t%s", opcode->name,
236	reg_names[OP_A(iword)]);
237	break;
238	case MOXIE_F1_AB:
239	fpr(stream, "%s\t%s, %s", opcode->name,
240	reg_names[OP_A(iword)],
241	reg_names[OP_B(iword)]);
242	break;
243	case MOXIE_F1_A4:
244	{
245	unsigned imm;
246	if ((status = info->read_memory_func(addr + 2, buffer, 4, info)))
247	goto fail;
248	imm = bfd_getb32(buffer);
249	fpr(stream, "%s\t%s, 0x%x", opcode->name,
250	reg_names[OP_A(iword)], imm);
251	length = 6;
252	}
253	break;
254	case MOXIE_F1_4:
255	{
256	unsigned imm;
257	if ((status = info->read_memory_func(addr + 2, buffer, 4, info)))
258	goto fail;
259	imm = bfd_getb32(buffer);
260	fpr(stream, "%s\t0x%x", opcode->name, imm);
261	length = 6;
262	}
263	break;
264	case MOXIE_F1_M:
265	{
266	unsigned imm;
267	if ((status = info->read_memory_func(addr + 2, buffer, 4, info)))
268	goto fail;
269	imm = bfd_getb32(buffer);
270	fpr(stream, "%s\t", opcode->name);
271	info->print_address_func((bfd_vma) imm, info);
272	length = 6;
273	}
274	break;
275	case MOXIE_F1_AiB:
276	fpr (stream, "%s\t(%s), %s", opcode->name,
277	reg_names[OP_A(iword)], reg_names[OP_B(iword)]);
278	break;
279	case MOXIE_F1_ABi:
280	fpr(stream, "%s\t%s, (%s)", opcode->name,
281	reg_names[OP_A(iword)], reg_names[OP_B(iword)]);
282	break;
283	case MOXIE_F1_4A:
284	{
285	unsigned imm;
286	if ((status = info->read_memory_func(addr + 2, buffer, 4, info)))
287	goto fail;
288	imm = bfd_getb32(buffer);
289	fpr(stream, "%s\t0x%x, %s",
290	opcode->name, imm, reg_names[OP_A(iword)]);
291	length = 6;
292	}
293	break;
294	case MOXIE_F1_AiB4:
295	{
296	unsigned imm;
297	if ((status = info->read_memory_func(addr+2, buffer, 4, info)))
298	goto fail;
299	imm = bfd_getb32(buffer);
300	fpr(stream, "%s\t0x%x(%s), %s", opcode->name,
301	imm,
302	reg_names[OP_A(iword)],
303	reg_names[OP_B(iword)]);
304	length = 6;
305	}
306	break;
307	case MOXIE_F1_ABi4:
308	{
309	unsigned imm;
310	if ((status = info->read_memory_func(addr+2, buffer, 4, info)))
311	goto fail;
312	imm = bfd_getb32(buffer);
313	fpr(stream, "%s\t%s, 0x%x(%s)",
314	opcode->name,
315	reg_names[OP_A(iword)],
316	imm,
317	reg_names[OP_B(iword)]);
318	length = 6;
319	}
320	break;
321	default:
322	abort();
323	}
324	}
325	else if ((iword & (1<<14)) == 0) {
326	/* Extract the Form 2 opcode. */
327	opcode = &moxie_form2_opc_info[(iword >> 12) & 3];
328	switch (opcode->itype) {
329	case MOXIE_F2_A8V:
330	fpr(stream, "%s\t%s, 0x%x",
331	opcode->name,
332	reg_names[(iword >> 8) & 0xf],
333	iword & ((1 << 8) - 1));
334	break;
335	case MOXIE_F2_NARG:
336	fpr(stream, "%s", opcode->name);
337	break;
338	default:
339	abort();
340	}
341	} else {
342	/* Extract the Form 3 opcode. */
343	opcode = &moxie_form3_opc_info[(iword >> 10) & 15];
344	switch (opcode->itype) {
345	case MOXIE_F3_PCREL:
346	fpr(stream, "%s\t", opcode->name);
347	info->print_address_func((bfd_vma) (addr + INST2OFFSET(iword) + 2),
348	info);
349	break;
350	default:
351	abort();
352	}
353	}
354
355	return length;
356
357	fail:
358	info->memory_error_func(status, addr, info);
359	return -1;
360	}