/* NDS32-specific support for 32-bit ELF.
Copyright (C) 2012-2014 Free Software Foundation, Inc.
Contributed by Andes Technology Corporation.
This file is part of BFD, the Binary File Descriptor library.
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 3 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, write to the Free Software
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
02110-1301, USA.*/
#include "sysdep.h"
#include <stdio.h>
#include "ansidecl.h"
#include "dis-asm.h"
#include "bfd.h"
#include "symcat.h"
#include "libiberty.h"
#include "opintl.h"
#include "bfd_stdint.h"
#define __MF(v, off, bs) ((v & ((1 << (bs)) - 1)) << (off))
#define __GF(v, off, bs) ((v >> (off)) & ((1 << (bs)) - 1))
#define __PF(v, off, bs, val) do { v = __put_field (v, off, bs, val); } while (0)
/* #define __SEXT(v, bs) ((v ^ (1 << (bs - 1))) - (1 << (bs - 1))) */
#define __SEXT(v, bs) (((v & ((1 << bs) - 1)) ^ (1 << (bs - 1))) - (1 << (bs - 1)))
#define __BIT(n) (1 << n)
/* Get fields */
#define OP6(insn) ((insn >> 25) & 0x3F)
#define RT5(insn) ((insn >> 20) & 0x1F)
#define RA5(insn) ((insn >> 15) & 0x1F)
#define RB5(insn) ((insn >> 10) & 0x1F)
#define RD5(insn) ((insn >> 5) & 0x1F)
#define SUB5(insn) ((insn >> 0) & 0x1F)
#define SUB10(insn) ((insn >> 0) & 0x3FF)
#define IMMU(insn, bs) (insn & ((1 << bs) - 1))
#define IMMS(insn, bs) __SEXT ((insn & ((1 << bs) - 1)), bs)
#define IMM1U(insn) IMMU ((insn >> 10), 5)
#define IMM1S(insn) IMMS ((insn >> 10), 5)
#define IMM2U(insn) IMMU ((insn >> 5), 5)
#define IMM2S(insn) IMMS ((insn >> 5), 5)
/* Default text to print if an instruction isn't recognized. */
#define UNKNOWN_INSN_MSG _("*unknown*")
static const char *mnemonic_op6[] =
{
"lbi", "lhi", "lwi", "ldi", "lbi.bi", "lhi.bi", "lwi.bi", "ldi.bi",
"sbi", "shi", "swi", "sdi", "sbi.bi", "shi.bi", "swi.bi", "sdi.bi",
"lbsi", "lhsi", "lwsi", "dprefi", "lbsi.bi", "lhsi.bi", "lwsi.bi", "lbgp",
"lwc", "swc", "ldc", "sdc", "mem", "lsmw", "hwgp", "sbgp",
"alu1", "alu2", "movi", "sethi", "ji", "jreg", "br1", "br2",
"addi", "subri", "andi", "xori", "ori", "br3", "slti", "sltsi",
"aext", "cext", "misc", "bitci", "op_64", "cop"
};
static const char *mnemonic_mem[] =
{
"lb", "lh", "lw", "ld", "lb.bi", "lh.bi", "lw.bi", "ld.bi",
"sb", "sh", "sw", "sd", "sb.bi", "sh.bi", "sw.bi", "sd.bi",
"lbs", "lhs", "lws", "dpref", "lbs.bi", "lhs.bi", "lws.bi", "27",
"llw", "scw", "32", "33", "34", "35", "36", "37",
"lbup", "41", "lwup", "43", "44", "45", "46", "47",
"sbup", "51", "swup"
};
static const char *mnemonic_alu1[] =
{
"add", "sub", "and", "xor", "or", "nor", "slt", "slts",
"slli", "srli", "srai", "rotri", "sll", "srl", "sra", "rotr",
"seb", "seh", "bitc", "zeh", "wsbh", "or_srli", "divsr", "divr",
"sva", "svs", "cmovz", "cmovn", "add_srli", "sub_srli", "and_srli", "xor_srli"
};
static const char *mnemonic_alu20[] =
{
"max", "min", "ave", "abs", "clips", "clip", "clo", "clz",
"bset", "bclr", "btgl", "btst", "bse", "bsp", "ffb", "ffmism",
"add.sc", "sub.sc", "add.wc", "sub.wc", "24", "25", "26", "ffzmism",
"qadd", "qsub", "32", "33", "34", "35", "36", "37",
"mfusr", "mtusr", "42", "43", "mul", "45", "46", "47",
"mults64", "mult64", "madds64", "madd64", "msubs64", "msub64", "divs", "div",
"60", "mult32", "62", "madd32", "64", "msub32", "65", "66",
"dmadd", "dmaddc", "dmsub", "dmsubc", "rmfhi", "qmflo"
};
static const char *mnemonic_alu21[] =
{
"00", "01", "02", "03", "04", "05", "06", "07",
"10", "11", "12", "13", "14", "15", "ffbi", "flmism",
"20", "21", "22", "23", "24", "25", "26", "27",
"30", "31", "32", "33", "34", "35", "36", "37",
"40", "41", "42", "43", "44", "45", "46", "47",
"mulsr64", "mulr64", "52", "53", "54", "55", "56", "57",
"60", "61", "62", "maddr32", "64", "msubr32", "66", "67",
"70", "71", "72", "73", "74", "75", "76", "77"
};
static const char *mnemonic_br2[] =
{
"ifcall", "01", "beqz", "bnez", "bgez", "bltz", "bgtz", "blez",
"10", "11", "12", "13", "bgezal", "bltzal"
};
static const char *mnemonic_misc[] =
{
"standby", "cctl", "mfsr", "mtsr", "iret", "trap", "teqz", "tnez",
"dsb", "isb", "break", "syscall", "msync", "isync", "tlbop"
};
static const char *mnemonic_hwgp[] =
{
"lhi.gp", "lhi.gp", "lhsi.gp", "lhsi.gp",
"shi.gp", "shi.gp", "lwi.gp", "swi.gp"
};
static const char *keyword_dpref[] =
{
"SRD", "MRD", "SWR", "MWR", "PTE", "CLWR", "6", "7",
"8", "9", "10", "11", "12", "13", "14", "15"
};
static const char *mnemonic_alu[] =
{
"fadds", "fsubs", "fcpynss", "fcpyss", "fmadds",
"fmsubs", "fcmovns", "fcmovzs", "fnmadds", "fnmsubs",
"10", "11", "fmuls", "fdivs", "faddd",
"fsubd", "fcpynsd", "fcpysd", "fmaddd", "fmsubd",
"fcmovnd", "fcmovzd", "fnmaddd", "fnmsubd", "24",
"25", "fmuld", "fdivd"
};
static const char *mnemonic_fpu_2op[] =
{
"fs2d", "fsqrts", "2", "3", "4", "fabss", "6", "7",
"fui2s", "9", "10", "11", "fsi2s", "13", "14", "15",
"fs2ui", "17", "18", "19", "fs2ui.z", "21", "22", "23",
"fs2si", "25", "26", "27", "fs2si.z", "fd2s", "fsqrtd", "31",
"32", "33", "fabsd", "35", "36", "fui2d", "38", "39",
"40", "fsi2d", "42", "43", "44", "fd2ui", "46", "47",
"48", "fd2ui.z", "50", "51", "52", "fd2si", "54", "55",
"56", "fd2si.z"
};
static const char *mnemonic_fs2_cmp[] =
{
"fcmpeqs", "fcmpeqs.e", "fcmplts", "fcmplts.e",
"fcmples", "fcmples.e", "fcmpuns", "fcmpuns.e"
};
static const char *mnemonic_fd2_cmp[] =
{
"fcmpeqd", "fcmpeqd.e", "fcmpltd", "fcmpltd.e",
"fcmpled", "fcmpled.e", "fcmpund", "fcmpund.e"
};
/* Register name table. */
/* General purpose register. */
static const char *gpr_map[] =
{
"$r0", "$r1", "$r2", "$r3", "$r4", "$r5", "$r6", "$r7",
"$r8", "$r9", "$r10", "$r11", "$r12", "$r13", "$r14", "$r15",
"$r16", "$r17", "$r18", "$r19", "$r20", "$r21", "$r22", "$r23",
"$r24", "$r25", "$r26", "$r27", "$fp", "$gp", "$lp", "$sp"
};
/* User special register. */
static const char *usr_map[][32] =
{
{
"d0.lo", "d0.hi", "d1.lo", "d1.hi", "4", "5", "6", "7",
"8", "9", "10", "11", "12", "13", "14", "15",
"16", "17", "18", "19", "20", "21", "22", "23",
"24", "25", "26", "27", "28", "29", "30", "pc"
},
{
"DMA_CFG", "DMA_GCSW", "DMA_CHNSEL", "DMA_ACT", "DMA_SETUP",
"DMA_ISADDR", "DMA_ESADDR", "DMA_TCNT", "DMA_STATUS", "DMA_2DSET",
"10", "11", "12", "13", "14",
"15", "16", "17", "18", "19",
"20", "21", "22", "23", "24",
"DMA_2DSCTL"
},
{
"PFMC0", "PFMC1", "PFMC2", "3", "PFM_CTL"
}
};
/* System register. */
/* Major Minor Extension. */
static const char *sr_map[8][16][8] =
{
{
{"CPU_VER", "CORE_ID"},
{"ICM_CFG"},
{"DCM_CFG"},
{"MMU_CFG"},
{"MSC_CFG"}
},
{
{"PSW", "IPSW", "P_IPSW"},
{"0", "IVB", "INT_CTRL"},
{"0", "EVA", "P_EVA"},
{"0", "ITYPE", "P_ITYPE"},
{"0", "MERR"},
{"0", "IPC", "P_IPC", "OIPC"},
{"0", "1", "P_P0"},
{"0", "1", "P_P1"},
{"INT_MASK", "INT_MASK2"},
{"INT_PEND", "INT_PEND2", "2", "3", "INT_TRIGGER"},
{"SP_USR", "SP_PRIV"},
{"INT_PRI", "INT_PRI2"}
},
{
{"MMU_CTL"},
{"L1_PPTB"},
{"TLB_VPN"},
{"TLB_DATA"},
{"TLB_MISC"},
{"VLPT_IDX"},
{"ILMB"},
{"DLMB"},
{"CACHE_CTL"},
{"HSMP_SADDR", "HSMP_EADDR"},
{"0"},
{"0"},
{"0"},
{"0"},
{"0"},
{"SDZ_CTL", "MISC_CTL"}
},
{
{"BPC0", "BPC1", "BPC2", "BPC3", "BPC4", "BPC5", "BPC6", "BPC7"},
{"BPA0", "BPA1", "BPA2", "BPA3", "BPA4", "BPA5", "BPA6", "BPA7"},
{"BPAM0", "BPAM1", "BPAM2", "BPAM3", "BPAM4", "BPAM5", "BPAM6", "BPAM7"},
{"BPV0", "BPV1", "BPV2", "BPV3", "BPV4", "BPV5", "BPV6", "BPV7"},
{"BPCID0", "BPCID1", "BPCID2", "BPCID3", "BPCID4", "BPCID5", "BPCID6", "BPCID7"},
{"EDM_CFG"},
{"EDMSW"},
{"EDM_CTL"},
{"EDM_DTR"},
{"BPMTC"},
{"DIMBR"},
{"EDM_PROBE"},
{"0"},
{"0"},
{"TECR0", "TECR1"}
},
{
{"PFMC0", "PFMC1", "PFMC2"},
{"PFM_CTL"},
{"0"},
{"0"},
{"PRUSR_ACC_CTL"},
{"FUCOP_CTL"}
},
{
{"DMA_CFG"},
{"DMA_GCSW"},
{"DMA_CHNSEL"},
{"DMA_ACT"},
{"DMA_SETUP"},
{"DMA_ISADDR"},
{"DMA_ESADDR"},
{"DMA_TCNT"},
{"DMA_STATUS"},
{"DMA_2DSET", "DMA_2DSCTL"}
}
};
static void
print_insn16 (bfd_vma pc, disassemble_info *info, uint32_t insn)
{
static char r4map[] =
{
0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 16, 17, 18, 19
};
const int rt5 = __GF (insn, 5, 5);
const int ra5 = __GF (insn, 0, 5);
const int rt4 = r4map[__GF (insn, 5, 4)];
const int imm5u = IMMU (insn, 5);
const int imm9u = IMMU (insn, 9);
const int rt3 = __GF (insn, 6, 3);
const int ra3 = __GF (insn, 3, 3);
const int rb3 = __GF (insn, 0, 3);
const int rt38 = __GF (insn, 8, 3);
const int imm3u = rb3;
fprintf_ftype func = info->fprintf_func;
void *stream = info->stream;
static const char *mnemonic_96[] =
{
"0x1", "0x1", "0x2", "0x3",
"add45", "sub45", "addi45", "subi45",
"srai45", "srli45", "slli333", "0xb",
"add333", "sub333", "addi333", "subi333",
"lwi333", "lwi333.bi", "lhi333", "lbi333",
"swi333", "swi333.bi", "shi333", "sbi333",
"addri36.sp", "lwi45.fe", "lwi450", "swi450",
"0x1c", "0x1d", "0x1e", "0x1f",
"0x20", "0x21", "0x22", "0x23",
"0x24", "0x25", "0x26", "0x27",
"0x28", "0x29", "0x2a", "0x2b",
"0x2c", "0x2d", "0x2e", "0x2f",
"slts45", "slt45", "sltsi45", "slti45",
"0x34", "0x35", "0x36", "0x37",
"0x38", "0x39", "0x3a", "0x3b",
"ifcall9", "movpi45"
};
static const char *mnemonic_misc33[] =
{
"misc33_0", "misc33_1", "neg33", "not33", "mul33", "xor33", "and33", "or33",
};
static const char *mnemonic_0xb[] =
{
"zeb33", "zeh33", "seb33", "seh33", "xlsb33", "x11b33", "bmski33", "fexti33"
};
static const char *mnemonic_bnes38[] =
{
"jr5", "jral5", "ex9.it", "?", "ret5", "add5.pc"
};
switch (__GF (insn, 7, 8))
{
case 0xf8: /* push25 */
case 0xf9: /* pop25 */
{
uint32_t res[] = { 6, 8, 10, 14 };
uint32_t re = res[__GF (insn, 5, 2)];
func (stream, "%s\t%s, %d", (insn & __BIT (7)) ? "pop25" : "push25",
gpr_map[re], imm5u << 3);
}
return;
}
if (__GF (insn, 8, 7) == 0x7d) /* movd44 */
{
int rt5e = __GF (insn, 4, 4) << 1;
int ra5e = IMMU (insn, 4) << 1;
func (stream, "movd44\t%s, %d", gpr_map[rt5e], ra5e);
return;
}
switch (__GF (insn, 9, 6))
{
case 0x4: /* add45 */
case 0x5: /* sub45 */
case 0x30: /* slts45 */
case 0x31: /* slt45 */
func (stream, "%s\t%s, %s", mnemonic_96[__GF (insn, 9, 6)],
gpr_map[rt4], gpr_map[ra5]);
return;
case 0x6: /* addi45 */
case 0x7: /* subi45 */
case 0x8: /* srai45 */
case 0x9: /* srli45 */
case 0x32: /* sltsi45 */
case 0x33: /* slti45 */
func (stream, "%s\t%s, %d", mnemonic_96[__GF (insn, 9, 6)],
gpr_map[rt4], ra5);
return;
case 0xc: /* add333 */
case 0xd: /* sub333 */
func (stream, "%s\t%s, %s, %s", mnemonic_96[__GF (insn, 9, 6)],
gpr_map[rt3], gpr_map[ra3], gpr_map[rb3]);
return;
case 0xa: /* slli333 */
case 0xe: /* addi333 */
case 0xf: /* subi333 */
func (stream, "%s\t%s, %s, %d", mnemonic_96[__GF (insn, 9, 6)],
gpr_map[rt3], gpr_map[ra3], imm3u);
return;
case 0x10: /* lwi333 */
case 0x14: /* swi333 */
func (stream, "%s\t%s, [%s + %d]", mnemonic_96[__GF (insn, 9, 6)],
gpr_map[rt3], gpr_map[ra3], imm3u << 2);
return;
case 0x12: /* lhi333 */
case 0x16: /* shi333 */
func (stream, "%s\t%s, [%s + %d]", mnemonic_96[__GF (insn, 9, 6)],
gpr_map[rt3], gpr_map[ra3], imm3u << 1);
return;
case 0x13: /* lbi333 */
case 0x17: /* sbi333 */
func (stream, "%s\t%s, [%s + %d]", mnemonic_96[__GF (insn, 9, 6)],
gpr_map[rt3], gpr_map[ra3], imm3u);
return;
case 0x11: /* lwi333.bi */
case 0x15: /* swi333.bi */
func (stream, "%s\t%s, [%s], %d", mnemonic_96[__GF (insn, 9, 6)],
gpr_map[rt3], gpr_map[ra3], imm3u << 2);
return;
case 0x18: /* addri36.sp */
func (stream, "%s\t%s, %d", mnemonic_96[__GF (insn, 9, 6)],
gpr_map[rt3], IMMU (insn, 6) << 2);
return;
case 0x19: /* lwi45.fe */
func (stream, "%s\t%s, %d", mnemonic_96[__GF (insn, 9, 6)],
gpr_map[rt4], -((32 - imm5u) << 2));
return;
case 0x1a: /* lwi450 */
case 0x1b: /* swi450 */
func (stream, "%s\t%s, [%s]", mnemonic_96[__GF (insn, 9, 6)],
gpr_map[rt4], gpr_map[ra5]);
return;
case 0x34: /* beqzs8, bnezs8 */
func (stream, "%s\t", ((insn & __BIT (8)) ? "bnezs8" : "beqzs8"));
info->print_address_func ((IMMS (insn, 8) << 1) + pc, info);
return;
case 0x35: /* break16, ex9.it */
/* FIXME: Check bfd_mach. */
if (imm9u < 32) /* break16 */
func (stream, "break16\t%d", imm9u);
else
func (stream, "ex9.it\t%d", imm9u);
return;
case 0x3c: /* ifcall9 */
func (stream, "%s\t", mnemonic_96[__GF (insn, 9, 6)]);
info->print_address_func ((IMMU (insn, 9) << 1) + pc, info);
return;
case 0x3d: /* movpi45 */
func (stream, "%s\t%s, %d", mnemonic_96[__GF (insn, 9, 6)],
gpr_map[rt4], ra5 + 16);
return;
case 0x3f: /* MISC33 */
func (stream, "%s\t%s, %s", mnemonic_misc33[rb3],
gpr_map[rt3], gpr_map[ra3]);
return;
case 0xb: /* ... */
func (stream, "%s\t%s, %s", mnemonic_0xb[rb3],
gpr_map[rt3], gpr_map[ra3]);
return;
}
switch (__GF (insn, 10, 5))
{
case 0x0: /* mov55 or ifret16 */
/* FIXME: Check bfd_mach. */
if (rt5 == ra5 && rt5 == 31)
func (stream, "ifret16");
else
func (stream, "mov55\t%s, %s", gpr_map[rt5], gpr_map[ra5]);
return;
case 0x1: /* movi55 */
func (stream, "movi55\t%s, %d", gpr_map[rt5], IMMS (insn, 5));
return;
case 0x1b: /* addi10s (V2) */
func (stream, "addi10s\t%d", IMMS (insn, 10));
return;
}
switch (__GF (insn, 11, 4))
{
case 0x7: /* lwi37.fp/swi37.fp */
func (stream, "%s\t%s, [$fp + 0x%x]",
((insn & __BIT (7)) ? "swi37" : "lwi37"),
gpr_map[rt38], IMMU (insn, 7) << 2);
return;
case 0x8: /* beqz38 */
case 0x9: /* bnez38 */
func (stream, "%s\t%s, ",
((__GF (insn, 11, 4) & 1) ? "bnez38" : "beqz38"), gpr_map[rt38]);
info->print_address_func ((IMMS (insn, 8) << 1) + pc, info);
return;
case 0xa: /* beqs38/j8, implied r5 */
if (rt38 == 5)
{
func (stream, "j8\t");
info->print_address_func ((IMMS (insn, 8) << 1) + pc, info);
}
else
{
func (stream, "beqs38\t%s, ", gpr_map[rt38]);
info->print_address_func ((IMMS (insn, 8) << 1) + pc, info);
}
return;
case 0xb: /* bnes38 and others */
if (rt38 == 5)
{
switch (__GF (insn, 5, 3))
{
case 0: /* jr5 */
case 1: /* jral5 */
case 4: /* ret5 */
func (stream, "%s\t%s", mnemonic_bnes38[__GF (insn, 5, 3)],
gpr_map[ra5]);
return;
case 2: /* ex9.it imm5 */
case 5: /* add5.pc */
func (stream, "%s\t%d", mnemonic_bnes38[__GF (insn, 5, 3)], ra5);
return;
default:
func (stream, UNKNOWN_INSN_MSG);
return;
}
}
else
{
func (stream, "bnes38\t%s", gpr_map[rt3]);
info->print_address_func ((IMMS (insn, 8) << 1) + pc, info);
}
return;
case 0xe: /* lwi37/swi37 */
func (stream, "%s\t%s, [+ 0x%x]",
((insn & __BIT (7)) ? "swi37.sp" : "lwi37.sp"),
gpr_map[rt38], IMMU (insn, 7) << 2);
return;
}
}
static void
print_insn32_mem (bfd_vma pc ATTRIBUTE_UNUSED, disassemble_info *info,
uint32_t insn)
{
const int rt = RT5 (insn);
const int ra = RA5 (insn);
const int rb = RB5 (insn);
const int sv = __GF (insn, 8, 2);
const int op = insn & 0xFF;
fprintf_ftype func = info->fprintf_func;
void *stream = info->stream;
switch (op)
{
case 0x0: /* lb */
case 0x1: /* lh */
case 0x2: /* lw */
case 0x3: /* ld */
case 0x8: /* sb */
case 0x9: /* sh */
case 0xa: /* sw */
case 0xb: /* sd */
case 0x10: /* lbs */
case 0x11: /* lhs */
case 0x12: /* lws */
case 0x18: /* llw */
case 0x19: /* scw */
case 0x20: /* lbup */
case 0x22: /* lwup */
case 0x28: /* sbup */
case 0x2a: /* swup */
func (stream, "%s\t%s, [%s + (%s << %d)]",
mnemonic_mem[op], gpr_map[rt], gpr_map[ra], gpr_map[rb], sv);
break;
case 0x4: /* lb.bi */
case 0x5: /* lh.bi */
case 0x6: /* lw.bi */
case 0x7: /* ld.bi */
case 0xc: /* sb.bi */
case 0xd: /* sh.bi */
case 0xe: /* sw.bi */
case 0xf: /* sd.bi */
case 0x14: /* lbs.bi */
case 0x15: /* lhs.bi */
case 0x16: /* lws.bi */
func (stream, "%s\t%s, [%s], (%s << %d)",
mnemonic_mem[op], gpr_map[rt], gpr_map[ra], gpr_map[rb], sv);
break;
case 0x13: /* dpref */
{
const char *subtype = "???";
if ((rt & 0xf) < ARRAY_SIZE (keyword_dpref))
subtype = keyword_dpref[rt & 0xf];
func (stream, "%s\t%s, [%s + (%s << %d)]",
"dpref", subtype, gpr_map[ra], gpr_map[rb], sv);
}
break;
default:
func (stream, UNKNOWN_INSN_MSG);
return;
}
}
static void
print_insn32_alu1 (bfd_vma pc ATTRIBUTE_UNUSED, disassemble_info *info, uint32_t insn)
{
int op = insn & 0x1f;
const int rt = RT5 (insn);
const int ra = RA5 (insn);
const int rb = RB5 (insn);
const int rd = RD5 (insn);
fprintf_ftype func = info->fprintf_func;
void *stream = info->stream;
switch (op)
{
case 0x0: /* add, add_slli */
case 0x1: /* sub, sub_slli */
case 0x2: /* and, add_slli */
case 0x3: /* xor, xor_slli */
case 0x4: /* or, or_slli */
if (rd != 0)
{
func (stream, "%s_slli\t%s, %s, %s, #%d",
mnemonic_alu1[op], gpr_map[rt], gpr_map[ra], gpr_map[rb], rd);
}
else
{
func (stream, "%s\t%s, %s, %s",
mnemonic_alu1[op], gpr_map[rt], gpr_map[ra], gpr_map[rb]);
}
return;
case 0x1c: /* add_srli */
case 0x1d: /* sub_srli */
case 0x1e: /* and_srli */
case 0x1f: /* xor_srli */
case 0x15: /* or_srli */
func (stream, "%s\t%s, %s, %s, #%d",
mnemonic_alu1[op], gpr_map[rt], gpr_map[ra], gpr_map[rb], rd);
return;
case 0x5: /* nor */
case 0x6: /* slt */
case 0x7: /* slts */
case 0xc: /* sll */
case 0xd: /* srl */
case 0xe: /* sra */
case 0xf: /* rotr */
case 0x12: /* bitc */
case 0x18: /* sva */
case 0x19: /* svs */
case 0x1a: /* cmovz */
case 0x1b: /* cmovn */
func (stream, "%s\t%s, %s, %s",
mnemonic_alu1[op], gpr_map[rt], gpr_map[ra], gpr_map[rb]);
return;
case 0x9: /* srli */
if (ra ==0 && rb == 0 && rb==0)
{
func (stream, "nop");
return;
}
case 0x8: /* slli */
case 0xa: /* srai */
case 0xb: /* rotri */
func (stream, "%s\t%s, %s, #%d",
mnemonic_alu1[op], gpr_map[rt], gpr_map[ra], rb);
return;
case 0x10: /* seb */
case 0x11: /* seh */
case 0x13: /* zeh */
case 0x14: /* wsbh */
func (stream, "%s\t%s, %s",
mnemonic_alu1[op], gpr_map[rt], gpr_map[ra]);
return;
case 0x16: /* divsr */
case 0x17: /* divr */
func (stream, "%s\t%s, %s, %s, %s",
mnemonic_alu1[op], gpr_map[rt], gpr_map[rd], gpr_map[ra], gpr_map[rb]);
return;
default:
func (stream, UNKNOWN_INSN_MSG);
return;
}
return;
}
static void
print_insn32_alu2 (bfd_vma pc ATTRIBUTE_UNUSED,
disassemble_info *info,
uint32_t insn)
{
int op = insn & 0x3ff;
const int rt = RT5 (insn);
const int ra = RA5 (insn);
const int rb = RB5 (insn);
fprintf_ftype func = info->fprintf_func;
void *stream = info->stream;
if ((insn & 0x7f) == 0x4e) /* ffbi */
{
func (stream, "ffbi\t%s, %s, #0x%x",
gpr_map[rt], gpr_map[ra], __GF (insn, 7, 8));
return;
}
switch (op)
{
case 0x0: /* max */
case 0x1: /* min */
case 0x2: /* ave */
case 0xc: /* bse */
case 0xd: /* bsp */
case 0xe: /* ffb */
case 0xf: /* ffmism */
case 0x17: /* ffzmism */
case 0x24: /* mul */
func (stream, "%s\t%s, %s, %s", mnemonic_alu20[op],
gpr_map[rt], gpr_map[ra], gpr_map[rb]);
return;
case 0x3: /* abs */
case 0x6: /* clo */
case 0x7: /* clz */
func (stream, "%s\t%s, %s", mnemonic_alu20[op], gpr_map[rt], gpr_map[ra]);
return;
case 0x4: /* clips */
case 0x5: /* clip */
case 0x8: /* bset */
case 0x9: /* bclr */
case 0xa: /* btgl */
case 0xb: /* btst */
func (stream, "%s\t%s, %s, #%d", mnemonic_alu20[op],
gpr_map[rt], gpr_map[ra], IMM1U (insn));
return;
case 0x20: /* mfusr */
case 0x21: /* mtusr */
func (stream, "%s\t%s, $%s", mnemonic_alu20[op],
gpr_map[rt], usr_map[__GF (insn, 10, 5)][__GF (insn, 15, 5)]);
return;
case 0x28: /* mults64 */
case 0x29: /* mult64 */
case 0x2a: /* madds64 */
case 0x2b: /* madd64 */
case 0x2c: /* msubs64 */
case 0x2d: /* msub64 */
case 0x2e: /* divs */
case 0x2f: /* div */
case 0x31: /* mult32 */
case 0x33: /* madd32 */
case 0x35: /* msub32 */
func (stream, "%s\t$d%d, %s, %s", mnemonic_alu20[op],
rt >> 1, gpr_map[ra], gpr_map[rb]);
return;
case 0x4f: /* flmism */
case 0x68: /* mulsr64 */
case 0x69: /* mulr64 */
case 0x73: /* maddr32 */
case 0x75: /* msubr32 */
op = insn & 0x3f;
func (stream, "%s\t%s, %s, %s", mnemonic_alu21[op],
gpr_map[rt], gpr_map[ra], gpr_map[rb]);
return;
default:
func (stream, UNKNOWN_INSN_MSG);
return;
}
}
static void
print_insn32_jreg (bfd_vma pc ATTRIBUTE_UNUSED, disassemble_info *info, uint32_t insn)
{
int op = insn & 0xff;
const int rt = RT5 (insn);
const int rb = RB5 (insn);
const char *dtit_on[] = { "", ".iton", ".dton", ".ton" };
const char *dtit_off[] = { "", ".itoff", ".dtoff", ".toff" };
const char *mnemonic_jreg[] = { "jr", "jral", "jrnez", "jralnez" };
const char *mnemonic_ret[] = { "jr", "ret", NULL, "ifret" };
const int dtit = __GF (insn, 8, 2);
fprintf_ftype func = info->fprintf_func;
void *stream = info->stream;
switch (op)
{
case 0: /* jr */
func (stream, "%s%s\t%s", mnemonic_ret[op >> 5],
dtit_on[dtit], gpr_map[rb]);
return;
case 0x20: /* ret */
func (stream, "%s%s\t%s", mnemonic_ret[op >> 5],
dtit_off[dtit], gpr_map[rb]);
return;
case 0x60: /* ifret */
break;
case 1: /* jral */
case 2: /* jrnez */
case 3: /* jralnez */
func (stream, "%s%s\t%s, %s", mnemonic_jreg[op],
dtit_on[dtit], gpr_map[rt], gpr_map[rb]);
return;
default: /* unknown */
func (stream, UNKNOWN_INSN_MSG);
break;
}
}
static void
print_insn32_misc (bfd_vma pc ATTRIBUTE_UNUSED, disassemble_info *info,
uint32_t insn)
{
int op = insn & 0x1f;
int rt = RT5 (insn);
unsigned int id;
fprintf_ftype func = info->fprintf_func;
void *stream = info->stream;
static const char *keyword_standby[] =
{
"no_wake_grant", "wake_grant", "wait_done",
};
static const char *keyword_tlbop[] =
{
"TRD", "TWR", "RWR", "RWLK", "UNLK", "PB", "INV", "FLUA"
};
switch (op)
{
case 0x0: /* standby */
id = __GF (insn, 5, 20);
if (id < ARRAY_SIZE (keyword_standby))
func (stream, "standby\t%s", keyword_standby[id]);
else
func (stream, "standby\t%d", id);
return;
case 0x1: /* cctl */
func (stream, "cctl\t!FIXME");
return;
case 0x8: /* dsb */
case 0x9: /* isb */
case 0xd: /* isync */
case 0xc: /* msync */
case 0x4: /* iret */
func (stream, "%s", mnemonic_misc[op]);
return;
case 0x5: /* trap */
case 0xa: /* break */
case 0xb: /* syscall */
id = __GF (insn, 5, 15);
func (stream, "%s\t%d", mnemonic_misc[op], id);
return;
case 0x2: /* mfsr */
case 0x3: /* mtsr */
/* FIXME: setend, setgie. */
func (stream, "%s\t%s, $%s", mnemonic_misc[op], gpr_map[rt],
sr_map[__GF(insn, 17, 3)][__GF(insn, 13, 4)][__GF(insn, 10, 3)]);
return;
case 0x6: /* teqz */
case 0x7: /* tnez */
id = __GF (insn, 5, 15);
func (stream, "%s\t%s, %d", mnemonic_misc[op], gpr_map[rt], id);
return;
case 0xe: /* tlbop */
id = __GF (insn, 5, 5);
if (id < ARRAY_SIZE (keyword_tlbop))
func (stream, "tlbop\t%s", keyword_tlbop[id]);
else
func (stream, "tlbop\t%d", id);
return;
}
}
static void
print_insn32_fpu (bfd_vma pc ATTRIBUTE_UNUSED, disassemble_info *info,
uint32_t insn)
{
int op = insn & 0xf;
int mask_sub_op = (insn & 0x3c0) >> 6;
int mask_bi = (insn & 0x80) >> 7;
int mask_cfg = (insn & 0x7c00) >> 10;
int mask_f2op = (insn & 0x7c00) >> 10;
int dp = 0;
int dp_insn = 0;
char wd = 's';
const int rt = RT5 (insn);
const int ra = RA5 (insn);
const int rb = RB5 (insn);
const int sv = __GF (insn, 8, 2);
fprintf_ftype func = info->fprintf_func;
void *stream = info->stream;
switch (op)
{
case 0x0: /* fs1 */
case 0x8: /* fd1 */
dp = (op & 0x8) ? 1 : 0;
if (dp)
{
wd = 'd';
dp_insn = 14;
}
else
{
wd = 's';
dp_insn = 0;
}
switch (mask_sub_op)
{
case 0x0:
case 0x1:
case 0x2:
case 0x3:
case 0x4:
case 0x5:
case 0x8:
case 0x9:
case 0xc:
case 0xd:
func (stream, "%s\t$f%c%d, $f%c%d, $f%c%d",
mnemonic_alu[mask_sub_op + dp_insn],
wd, rt, wd, ra, wd, rb);
return;
case 0x6:
case 0x7:
func (stream, "%s\t$f%c%d, $f%c%d, $fs%d",
mnemonic_alu[mask_sub_op + dp_insn],
wd, rt, wd, ra, rb);
return;
case 0xf:
if (dp)
{
wd = 'd';
dp_insn = 0x1d;
}
else
{
wd = 's';
dp_insn = 0;
}
switch (mask_f2op)
{
case 0x0:
if (dp)
func (stream, "%s\t$fs%d, $fd%d",
mnemonic_fpu_2op[mask_f2op + dp_insn], rt, ra);
else
func (stream, "%s\t$fd%d, $fs%d",
mnemonic_fpu_2op[mask_f2op + dp_insn], rt, ra);
return;
case 0x1:
case 0x5:
func (stream, "%s\t$f%c%d, $f%c%d",
mnemonic_fpu_2op[mask_f2op + dp_insn], wd, rt, wd, ra);
return;
case 0x8:
case 0xc:
func (stream, "%s\t$f%c%d, $fs%d",
mnemonic_fpu_2op[mask_f2op + dp_insn], wd, rt, ra);
return;
case 0x10:
case 0x14:
case 0x18:
case 0x1c:
func (stream, "%s\t$fs%d, $f%c%d",
mnemonic_fpu_2op[mask_f2op + dp_insn], rt, wd, ra);
return;
}
}
case 0x1: /* mfcp */
switch (mask_sub_op)
{
case 0x0:
func (stream, "fmfsr\t%s, $fs%d", gpr_map[rt], ra);
return;
case 0x1:
func (stream, "fmfdr\t%s, $fd%d", gpr_map[rt], ra);
return;
case 0xc:
if (mask_cfg)
func (stream, "fmfcsr\t%s", gpr_map[rt]);
else
func (stream, "fmfcfg\t%s", gpr_map[rt]);
return;
}
case 0x2: /* fls */
if (mask_bi)
func (stream, "fls.bi\t$fs%d, [%s], (%s << %d)",
rt, gpr_map[ra], gpr_map[rb], sv);
else
func (stream, "fls\t$fs%d, [%s + (%s << %d)]",
rt, gpr_map[ra], gpr_map[rb], sv);
return;
case 0x3: /* fld */
if (mask_bi)
func (stream, "fld.bi\t$fd%d, [%s], (%s << %d)",
rt, gpr_map[ra], gpr_map[rb], sv);
else
func (stream, "fld\t$fd%d, [%s + (%s << %d)]",
rt, gpr_map[ra], gpr_map[rb], sv);
return;
case 0x4: /* fs2 */
func (stream, "%s\t$fs%d, $fs%d, $fs%d",
mnemonic_fs2_cmp[mask_sub_op], rt, ra, rb);
return;
case 0x9: /* mtcp */
switch (mask_sub_op)
{
case 0x0:
func (stream, "fmtsr\t%s, $fs%d", gpr_map[rt], ra);
return;
case 0x1:
func (stream, "fmtdr\t%s, $fd%d", gpr_map[rt], ra);
return;
case 0xc:
func (stream, "fmtcsr\t%s", gpr_map[rt]);
return;
}
case 0xa: /* fss */
if (mask_bi)
func (stream, "fss.bi\t$fs%d, [%s], (%s << %d)",
rt, gpr_map[ra], gpr_map[rb], sv);
else
func (stream, "fss\t$fs%d, [%s + (%s << %d)]",
rt, gpr_map[ra], gpr_map[rb], sv);
return;
case 0xb: /* fsd */
if (mask_bi)
func (stream, "fsd.bi\t$fd%d, [%s], (%s << %d)",
rt, gpr_map[ra], gpr_map[rb], sv);
else
func (stream, "fsd\t$fd%d, [%s + (%s << %d)]",
rt, gpr_map[ra], gpr_map[rb], sv);
return;
case 0xc: /* fd2 */
func (stream, "%s\t$fs%d, $fd%d, $fd%d",
mnemonic_fd2_cmp[mask_sub_op], rt, ra, rb);
return;
}
}
static void
print_insn32 (bfd_vma pc, disassemble_info *info, uint32_t insn)
{
int op = OP6 (insn);
const int rt = RT5 (insn);
const int ra = RA5 (insn);
const int rb = RB5 (insn);
const int imm15s = IMMS (insn, 15);
const int imm15u = IMMU (insn, 15);
uint32_t shift;
fprintf_ftype func = info->fprintf_func;
void *stream = info->stream;
switch (op)
{
case 0x0: /* lbi */
case 0x1: /* lhi */
case 0x2: /* lwi */
case 0x3: /* ldi */
case 0x8: /* sbi */
case 0x9: /* shi */
case 0xa: /* swi */
case 0xb: /* sdi */
case 0x10: /* lbsi */
case 0x11: /* lhsi */
case 0x12: /* lwsi */
shift = op & 0x3;
func (stream, "%s\t%s, [%s + #%d]",
mnemonic_op6[op], gpr_map[rt], gpr_map[ra], imm15s << shift);
return;
case 0x4: /* lbi.bi */
case 0x5: /* lhi.bi */
case 0x6: /* lwi.bi */
case 0x7: /* ldi.bi */
case 0xc: /* sbi.bi */
case 0xd: /* shi.bi */
case 0xe: /* swi.bi */
case 0xf: /* sdi.bi */
case 0x14: /* lbsi.bi */
case 0x15: /* lhsi.bi */
case 0x16: /* lwsi.bi */
shift = op & 0x3;
func (stream, "%s\t%s, [%s], #%d",
mnemonic_op6[op], gpr_map[rt], gpr_map[ra], imm15s << shift);
return;
case 0x13: /* dprefi */
{
const char *subtype = "???";
char wd = 'w';
shift = 2;
/* d-bit */
if (rt & 0x10)
{
wd = 'd';
shift = 3;
}
if ((rt & 0xf) < ARRAY_SIZE (keyword_dpref))
subtype = keyword_dpref[rt & 0xf];
func (stream, "%s.%c\t%s, [%s + #%d]",
mnemonic_op6[op], wd, subtype, gpr_map[ra], imm15s << shift);
}
return;
case 0x17: /* LBGP */
func (stream, "%s\t%s, [+ %d]",
((insn & __BIT (19)) ? "lbsi.gp" : "lbi.gp"),
gpr_map[rt], IMMS (insn, 19));
return;
case 0x18: /* LWC */
case 0x19: /* SWC */
case 0x1a: /* LDC */
case 0x1b: /* SDC */
if (__GF (insn, 13, 2) == 0)
{
char ls = (op & 1) ? 's' : 'l';
char wd = (op & 2) ? 'd' : 's';
if (insn & __BIT (12))
{
func (stream, "f%c%ci.bi\t$f%c%d, [%s], %d", ls, wd,
wd, rt, gpr_map[ra], IMMS (insn, 12) << 2);
}
else
{
func (stream, "f%c%ci\t$f%c%d, [%s + %d]", ls, wd,
wd, rt, gpr_map[ra], IMMS (insn, 12) << 2);
}
}
else
{
char ls = (op & 1) ? 's' : 'l';
char wd = (op & 2) ? 'd' : 'w';
int cp = __GF (insn, 13, 2);
if (insn & __BIT (12))
{
func (stream, "cp%c%ci\tcp%d, $cpr%d, [%s], %d", ls, wd,
cp, rt, gpr_map[ra], IMMS (insn, 12) << 2);
}
else
{
func (stream, "cp%c%ci\tcp%d, $cpr%d, [%s + %d]", ls, wd,
cp, rt, gpr_map[ra], IMMS (insn, 12) << 2);
}
}
return;
case 0x1c: /* MEM */
print_insn32_mem (pc, info, insn);
return;
case 0x1d: /* LSMW */
{
int enb4 = __GF (insn, 6, 4);
char ls = (insn & __BIT (5)) ? 's' : 'l';
char ab = (insn & __BIT (4)) ? 'a' : 'b';
char *di = (insn & __BIT (3)) ? "d" : "i";
char *m = (insn & __BIT (2)) ? "m" : "";
static const char *s[] = {"", "a", "zb", "?"};
/* lsmwzb only always increase. */
if ((insn & 0x3) == 2)
di = "";
func (stream, "%cmw%s.%c%s%s\t%s, [%s], %s, 0x%x",
ls, s[insn & 0x3], ab, di, m, gpr_map[rt],
gpr_map[ra], gpr_map[rb], enb4);
}
return;
case 0x1e: /* HWGP */
op = __GF (insn, 17, 3);
switch (op)
{
case 0: case 1: /* lhi.gp */
case 2: case 3: /* lhsi.gp */
case 4: case 5: /* shi.gp */
func (stream, "%s\t%s, [+ %d]",
mnemonic_hwgp[op], gpr_map[rt], IMMS (insn, 18) << 1);
return;
case 6: /* lwi.gp */
case 7: /* swi.gp */
func (stream, "%s\t%s, [+ %d]",
mnemonic_hwgp[op], gpr_map[rt], IMMS (insn, 17) << 2);
return;
}
return;
case 0x1f: /* SBGP */
if (insn & __BIT (19))
func (stream, "addi.gp\t%s, %d",
gpr_map[rt], IMMS (insn, 19));
else
func (stream, "sbi.gp\t%s, [+ %d]",
gpr_map[rt], IMMS (insn, 19));
return;
case 0x20: /* ALU_1 */
print_insn32_alu1 (pc, info, insn);
return;
case 0x21: /* ALU_2 */
print_insn32_alu2 (pc, info, insn);
return;
case 0x22: /* movi */
func (stream, "movi\t%s, %d", gpr_map[rt], IMMS (insn, 20));
return;
case 0x23: /* sethi */
func (stream, "sethi\t%s, 0x%x", gpr_map[rt], IMMU (insn, 20));
return;
case 0x24: /* ji, jal */
/* FIXME: Handle relocation. */
if (info->flags & INSN_HAS_RELOC)
pc = 0;
func (stream, "%s\t", ((insn & __BIT (24)) ? "jal" : "j"));
info->print_address_func ((IMMS (insn, 24) << 1) + pc, info);
return;
case 0x25: /* jreg */
print_insn32_jreg (pc, info, insn);
return;
case 0x26: /* br1 */
func (stream, "%s\t%s, %s, ", ((insn & __BIT (14)) ? "bne" : "beq"),
gpr_map[rt], gpr_map[ra]);
info->print_address_func ((IMMS (insn, 14) << 1) + pc, info);
return;
case 0x27: /* br2 */
func (stream, "%s\t%s, ", mnemonic_br2[__GF (insn, 16, 4)],
gpr_map[rt]);
info->print_address_func ((IMMS (insn, 16) << 1) + pc, info);
return;
case 0x28: /* addi */
case 0x2e: /* slti */
case 0x2f: /* sltsi */
case 0x29: /* subri */
func (stream, "%s\t%s, %s, %d",
mnemonic_op6[op], gpr_map[rt], gpr_map[ra], imm15s);
return;
case 0x2a: /* andi */
case 0x2b: /* xori */
case 0x2c: /* ori */
case 0x33: /* bitci */
func (stream, "%s\t%s, %s, %d",
mnemonic_op6[op], gpr_map[rt], gpr_map[ra], imm15u);
return;
case 0x2d: /* br3, beqc, bnec */
func (stream, "%s\t%s, %d, ", ((insn & __BIT (19)) ? "bnec" : "beqc"),
gpr_map[rt], __SEXT (__GF (insn, 8, 11), 11));
info->print_address_func ((IMMS (insn, 8) << 1) + pc, info);
return;
case 0x32: /* misc */
print_insn32_misc (pc, info, insn);
return;
case 0x35: /* FPU */
print_insn32_fpu (pc, info, insn);
return;
}
}
int
print_insn_nds32 (bfd_vma pc, disassemble_info *info)
{
int status;
bfd_byte buf[4];
uint32_t insn;
status = info->read_memory_func (pc, (bfd_byte *) buf, 2, info);
if (status)
return -1;
/* 16-bit instruction. */
if (buf[0] & 0x80)
{
insn = bfd_getb16 (buf);
print_insn16 (pc, info, insn);
return 2;
}
/* 32-bit instructions. */
status = info->read_memory_func (pc + 2, (bfd_byte *) buf + 2, 2, info);
if (status)
return -1;
insn = bfd_getb32 (buf);
print_insn32 (pc, info, insn);
return 4;
}