opcodes/mips-dis.c

   1 /* Print mips instructions for GDB, the GNU debugger, or for objdump.
   2    Copyright 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2005, 2007, 2008
   4    Free Software Foundation, Inc.
   5    Contributed by Nobuyuki Hikichi(hikichi@sra.co.jp).
   6
   7    This file is part of the GNU opcodes library.
   8
   9    This library is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3, or (at your option)
  12    any later version.
  13
  14    It is distributed in the hope that it will be useful, but WITHOUT
  15    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  16    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  17    License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  22    MA 02110-1301, USA.  */
  23
  24 #include "sysdep.h"
  25 #include "dis-asm.h"
  26 #include "libiberty.h"
  27 #include "opcode/mips.h"
  28 #include "opintl.h"
  29
  30 /* FIXME: These are needed to figure out if the code is mips16 or
  31    not. The low bit of the address is often a good indicator.  No
  32    symbol table is available when this code runs out in an embedded
  33    system as when it is used for disassembler support in a monitor.  */
  34
  35 #if !defined(EMBEDDED_ENV)
  36 #define SYMTAB_AVAILABLE 1
  37 #include "elf-bfd.h"
  38 #include "elf/mips.h"
  39 #endif
  40
  41 /* Mips instructions are at maximum this many bytes long.  */
  42 #define INSNLEN 4
  43
  44 \f
  45 /* FIXME: These should be shared with gdb somehow.  */
  46
  47 struct mips_cp0sel_name
  48 {
  49   unsigned int cp0reg;
  50   unsigned int sel;
  51   const char * const name;
  52 };
  53
  54 /* The mips16 registers.  */
  55 static const unsigned int mips16_to_32_reg_map[] =
  56 {
  57   16, 17, 2, 3, 4, 5, 6, 7
  58 };
  59
  60 #define mips16_reg_names(rn)    mips_gpr_names[mips16_to_32_reg_map[rn]]
  61
  62
  63 static const char * const mips_gpr_names_numeric[32] =
  64 {
  65   "$0",   "$1",   "$2",   "$3",   "$4",   "$5",   "$6",   "$7",
  66   "$8",   "$9",   "$10",  "$11",  "$12",  "$13",  "$14",  "$15",
  67   "$16",  "$17",  "$18",  "$19",  "$20",  "$21",  "$22",  "$23",
  68   "$24",  "$25",  "$26",  "$27",  "$28",  "$29",  "$30",  "$31"
  69 };
  70
  71 static const char * const mips_gpr_names_oldabi[32] =
  72 {
  73   "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
  74   "t0",   "t1",   "t2",   "t3",   "t4",   "t5",   "t6",   "t7",
  75   "s0",   "s1",   "s2",   "s3",   "s4",   "s5",   "s6",   "s7",
  76   "t8",   "t9",   "k0",   "k1",   "gp",   "sp",   "s8",   "ra"
  77 };
  78
  79 static const char * const mips_gpr_names_newabi[32] =
  80 {
  81   "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
  82   "a4",   "a5",   "a6",   "a7",   "t0",   "t1",   "t2",   "t3",
  83   "s0",   "s1",   "s2",   "s3",   "s4",   "s5",   "s6",   "s7",
  84   "t8",   "t9",   "k0",   "k1",   "gp",   "sp",   "s8",   "ra"
  85 };
  86
  87 static const char * const mips_fpr_names_numeric[32] =
  88 {
  89   "$f0",  "$f1",  "$f2",  "$f3",  "$f4",  "$f5",  "$f6",  "$f7",
  90   "$f8",  "$f9",  "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
  91   "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
  92   "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31"
  93 };
  94
  95 static const char * const mips_fpr_names_32[32] =
  96 {
  97   "fv0",  "fv0f", "fv1",  "fv1f", "ft0",  "ft0f", "ft1",  "ft1f",
  98   "ft2",  "ft2f", "ft3",  "ft3f", "fa0",  "fa0f", "fa1",  "fa1f",
  99   "ft4",  "ft4f", "ft5",  "ft5f", "fs0",  "fs0f", "fs1",  "fs1f",
 100   "fs2",  "fs2f", "fs3",  "fs3f", "fs4",  "fs4f", "fs5",  "fs5f"
 101 };
 102
 103 static const char * const mips_fpr_names_n32[32] =
 104 {
 105   "fv0",  "ft14", "fv1",  "ft15", "ft0",  "ft1",  "ft2",  "ft3",
 106   "ft4",  "ft5",  "ft6",  "ft7",  "fa0",  "fa1",  "fa2",  "fa3",
 107   "fa4",  "fa5",  "fa6",  "fa7",  "fs0",  "ft8",  "fs1",  "ft9",
 108   "fs2",  "ft10", "fs3",  "ft11", "fs4",  "ft12", "fs5",  "ft13"
 109 };
 110
 111 static const char * const mips_fpr_names_64[32] =
 112 {
 113   "fv0",  "ft12", "fv1",  "ft13", "ft0",  "ft1",  "ft2",  "ft3",
 114   "ft4",  "ft5",  "ft6",  "ft7",  "fa0",  "fa1",  "fa2",  "fa3",
 115   "fa4",  "fa5",  "fa6",  "fa7",  "ft8",  "ft9",  "ft10", "ft11",
 116   "fs0",  "fs1",  "fs2",  "fs3",  "fs4",  "fs5",  "fs6",  "fs7"
 117 };
 118
 119 static const char * const mips_cp0_names_numeric[32] =
 120 {
 121   "$0",   "$1",   "$2",   "$3",   "$4",   "$5",   "$6",   "$7",
 122   "$8",   "$9",   "$10",  "$11",  "$12",  "$13",  "$14",  "$15",
 123   "$16",  "$17",  "$18",  "$19",  "$20",  "$21",  "$22",  "$23",
 124   "$24",  "$25",  "$26",  "$27",  "$28",  "$29",  "$30",  "$31"
 125 };
 126
 127 static const char * const mips_cp0_names_r3000[32] =
 128 {
 129   "c0_index",     "c0_random",    "c0_entrylo",   "$3",
 130   "c0_context",   "$5",           "$6",           "$7",
 131   "c0_badvaddr",  "$9",           "c0_entryhi",   "$11",
 132   "c0_sr",        "c0_cause",     "c0_epc",       "c0_prid",
 133   "$16",          "$17",          "$18",          "$19",
 134   "$20",          "$21",          "$22",          "$23",
 135   "$24",          "$25",          "$26",          "$27",
 136   "$28",          "$29",          "$30",          "$31",
 137 };
 138
 139 static const char * const mips_cp0_names_r4000[32] =
 140 {
 141   "c0_index",     "c0_random",    "c0_entrylo0",  "c0_entrylo1",
 142   "c0_context",   "c0_pagemask",  "c0_wired",     "$7",
 143   "c0_badvaddr",  "c0_count",     "c0_entryhi",   "c0_compare",
 144   "c0_sr",        "c0_cause",     "c0_epc",       "c0_prid",
 145   "c0_config",    "c0_lladdr",    "c0_watchlo",   "c0_watchhi",
 146   "c0_xcontext",  "$21",          "$22",          "$23",
 147   "$24",          "$25",          "c0_ecc",       "c0_cacheerr",
 148   "c0_taglo",     "c0_taghi",     "c0_errorepc",  "$31",
 149 };
 150
 151 static const char * const mips_cp0_names_mips3264[32] =
 152 {
 153   "c0_index",     "c0_random",    "c0_entrylo0",  "c0_entrylo1",
 154   "c0_context",   "c0_pagemask",  "c0_wired",     "$7",
 155   "c0_badvaddr",  "c0_count",     "c0_entryhi",   "c0_compare",
 156   "c0_status",    "c0_cause",     "c0_epc",       "c0_prid",
 157   "c0_config",    "c0_lladdr",    "c0_watchlo",   "c0_watchhi",
 158   "c0_xcontext",  "$21",          "$22",          "c0_debug",
 159   "c0_depc",      "c0_perfcnt",   "c0_errctl",    "c0_cacheerr",
 160   "c0_taglo",     "c0_taghi",     "c0_errorepc",  "c0_desave",
 161 };
 162
 163 static const struct mips_cp0sel_name mips_cp0sel_names_mips3264[] =
 164 {
 165   { 16, 1, "c0_config1"         },
 166   { 16, 2, "c0_config2"         },
 167   { 16, 3, "c0_config3"         },
 168   { 18, 1, "c0_watchlo,1"       },
 169   { 18, 2, "c0_watchlo,2"       },
 170   { 18, 3, "c0_watchlo,3"       },
 171   { 18, 4, "c0_watchlo,4"       },
 172   { 18, 5, "c0_watchlo,5"       },
 173   { 18, 6, "c0_watchlo,6"       },
 174   { 18, 7, "c0_watchlo,7"       },
 175   { 19, 1, "c0_watchhi,1"       },
 176   { 19, 2, "c0_watchhi,2"       },
 177   { 19, 3, "c0_watchhi,3"       },
 178   { 19, 4, "c0_watchhi,4"       },
 179   { 19, 5, "c0_watchhi,5"       },
 180   { 19, 6, "c0_watchhi,6"       },
 181   { 19, 7, "c0_watchhi,7"       },
 182   { 25, 1, "c0_perfcnt,1"       },
 183   { 25, 2, "c0_perfcnt,2"       },
 184   { 25, 3, "c0_perfcnt,3"       },
 185   { 25, 4, "c0_perfcnt,4"       },
 186   { 25, 5, "c0_perfcnt,5"       },
 187   { 25, 6, "c0_perfcnt,6"       },
 188   { 25, 7, "c0_perfcnt,7"       },
 189   { 27, 1, "c0_cacheerr,1"      },
 190   { 27, 2, "c0_cacheerr,2"      },
 191   { 27, 3, "c0_cacheerr,3"      },
 192   { 28, 1, "c0_datalo"          },
 193   { 29, 1, "c0_datahi"          }
 194 };
 195
 196 static const char * const mips_cp0_names_mips3264r2[32] =
 197 {
 198   "c0_index",     "c0_random",    "c0_entrylo0",  "c0_entrylo1",
 199   "c0_context",   "c0_pagemask",  "c0_wired",     "c0_hwrena",
 200   "c0_badvaddr",  "c0_count",     "c0_entryhi",   "c0_compare",
 201   "c0_status",    "c0_cause",     "c0_epc",       "c0_prid",
 202   "c0_config",    "c0_lladdr",    "c0_watchlo",   "c0_watchhi",
 203   "c0_xcontext",  "$21",          "$22",          "c0_debug",
 204   "c0_depc",      "c0_perfcnt",   "c0_errctl",    "c0_cacheerr",
 205   "c0_taglo",     "c0_taghi",     "c0_errorepc",  "c0_desave",
 206 };
 207
 208 static const struct mips_cp0sel_name mips_cp0sel_names_mips3264r2[] =
 209 {
 210   {  4, 1, "c0_contextconfig"   },
 211   {  0, 1, "c0_mvpcontrol"      },
 212   {  0, 2, "c0_mvpconf0"        },
 213   {  0, 3, "c0_mvpconf1"        },
 214   {  1, 1, "c0_vpecontrol"      },
 215   {  1, 2, "c0_vpeconf0"        },
 216   {  1, 3, "c0_vpeconf1"        },
 217   {  1, 4, "c0_yqmask"          },
 218   {  1, 5, "c0_vpeschedule"     },
 219   {  1, 6, "c0_vpeschefback"    },
 220   {  2, 1, "c0_tcstatus"        },
 221   {  2, 2, "c0_tcbind"          },
 222   {  2, 3, "c0_tcrestart"       },
 223   {  2, 4, "c0_tchalt"          },
 224   {  2, 5, "c0_tccontext"       },
 225   {  2, 6, "c0_tcschedule"      },
 226   {  2, 7, "c0_tcschefback"     },
 227   {  5, 1, "c0_pagegrain"       },
 228   {  6, 1, "c0_srsconf0"        },
 229   {  6, 2, "c0_srsconf1"        },
 230   {  6, 3, "c0_srsconf2"        },
 231   {  6, 4, "c0_srsconf3"        },
 232   {  6, 5, "c0_srsconf4"        },
 233   { 12, 1, "c0_intctl"          },
 234   { 12, 2, "c0_srsctl"          },
 235   { 12, 3, "c0_srsmap"          },
 236   { 15, 1, "c0_ebase"           },
 237   { 16, 1, "c0_config1"         },
 238   { 16, 2, "c0_config2"         },
 239   { 16, 3, "c0_config3"         },
 240   { 18, 1, "c0_watchlo,1"       },
 241   { 18, 2, "c0_watchlo,2"       },
 242   { 18, 3, "c0_watchlo,3"       },
 243   { 18, 4, "c0_watchlo,4"       },
 244   { 18, 5, "c0_watchlo,5"       },
 245   { 18, 6, "c0_watchlo,6"       },
 246   { 18, 7, "c0_watchlo,7"       },
 247   { 19, 1, "c0_watchhi,1"       },
 248   { 19, 2, "c0_watchhi,2"       },
 249   { 19, 3, "c0_watchhi,3"       },
 250   { 19, 4, "c0_watchhi,4"       },
 251   { 19, 5, "c0_watchhi,5"       },
 252   { 19, 6, "c0_watchhi,6"       },
 253   { 19, 7, "c0_watchhi,7"       },
 254   { 23, 1, "c0_tracecontrol"    },
 255   { 23, 2, "c0_tracecontrol2"   },
 256   { 23, 3, "c0_usertracedata"   },
 257   { 23, 4, "c0_tracebpc"        },
 258   { 25, 1, "c0_perfcnt,1"       },
 259   { 25, 2, "c0_perfcnt,2"       },
 260   { 25, 3, "c0_perfcnt,3"       },
 261   { 25, 4, "c0_perfcnt,4"       },
 262   { 25, 5, "c0_perfcnt,5"       },
 263   { 25, 6, "c0_perfcnt,6"       },
 264   { 25, 7, "c0_perfcnt,7"       },
 265   { 27, 1, "c0_cacheerr,1"      },
 266   { 27, 2, "c0_cacheerr,2"      },
 267   { 27, 3, "c0_cacheerr,3"      },
 268   { 28, 1, "c0_datalo"          },
 269   { 28, 2, "c0_taglo1"          },
 270   { 28, 3, "c0_datalo1"         },
 271   { 28, 4, "c0_taglo2"          },
 272   { 28, 5, "c0_datalo2"         },
 273   { 28, 6, "c0_taglo3"          },
 274   { 28, 7, "c0_datalo3"         },
 275   { 29, 1, "c0_datahi"          },
 276   { 29, 2, "c0_taghi1"          },
 277   { 29, 3, "c0_datahi1"         },
 278   { 29, 4, "c0_taghi2"          },
 279   { 29, 5, "c0_datahi2"         },
 280   { 29, 6, "c0_taghi3"          },
 281   { 29, 7, "c0_datahi3"         },
 282 };
 283
 284 /* SB-1: MIPS64 (mips_cp0_names_mips3264) with minor mods.  */
 285 static const char * const mips_cp0_names_sb1[32] =
 286 {
 287   "c0_index",     "c0_random",    "c0_entrylo0",  "c0_entrylo1",
 288   "c0_context",   "c0_pagemask",  "c0_wired",     "$7",
 289   "c0_badvaddr",  "c0_count",     "c0_entryhi",   "c0_compare",
 290   "c0_status",    "c0_cause",     "c0_epc",       "c0_prid",
 291   "c0_config",    "c0_lladdr",    "c0_watchlo",   "c0_watchhi",
 292   "c0_xcontext",  "$21",          "$22",          "c0_debug",
 293   "c0_depc",      "c0_perfcnt",   "c0_errctl",    "c0_cacheerr_i",
 294   "c0_taglo_i",   "c0_taghi_i",   "c0_errorepc",  "c0_desave",
 295 };
 296
 297 static const struct mips_cp0sel_name mips_cp0sel_names_sb1[] =
 298 {
 299   { 16, 1, "c0_config1"         },
 300   { 18, 1, "c0_watchlo,1"       },
 301   { 19, 1, "c0_watchhi,1"       },
 302   { 22, 0, "c0_perftrace"       },
 303   { 23, 3, "c0_edebug"          },
 304   { 25, 1, "c0_perfcnt,1"       },
 305   { 25, 2, "c0_perfcnt,2"       },
 306   { 25, 3, "c0_perfcnt,3"       },
 307   { 25, 4, "c0_perfcnt,4"       },
 308   { 25, 5, "c0_perfcnt,5"       },
 309   { 25, 6, "c0_perfcnt,6"       },
 310   { 25, 7, "c0_perfcnt,7"       },
 311   { 26, 1, "c0_buserr_pa"       },
 312   { 27, 1, "c0_cacheerr_d"      },
 313   { 27, 3, "c0_cacheerr_d_pa"   },
 314   { 28, 1, "c0_datalo_i"        },
 315   { 28, 2, "c0_taglo_d"         },
 316   { 28, 3, "c0_datalo_d"        },
 317   { 29, 1, "c0_datahi_i"        },
 318   { 29, 2, "c0_taghi_d"         },
 319   { 29, 3, "c0_datahi_d"        },
 320 };
 321
 322 static const char * const mips_hwr_names_numeric[32] =
 323 {
 324   "$0",   "$1",   "$2",   "$3",   "$4",   "$5",   "$6",   "$7",
 325   "$8",   "$9",   "$10",  "$11",  "$12",  "$13",  "$14",  "$15",
 326   "$16",  "$17",  "$18",  "$19",  "$20",  "$21",  "$22",  "$23",
 327   "$24",  "$25",  "$26",  "$27",  "$28",  "$29",  "$30",  "$31"
 328 };
 329
 330 static const char * const mips_hwr_names_mips3264r2[32] =
 331 {
 332   "hwr_cpunum",   "hwr_synci_step", "hwr_cc",     "hwr_ccres",
 333   "$4",          "$5",            "$6",           "$7",
 334   "$8",   "$9",   "$10",  "$11",  "$12",  "$13",  "$14",  "$15",
 335   "$16",  "$17",  "$18",  "$19",  "$20",  "$21",  "$22",  "$23",
 336   "$24",  "$25",  "$26",  "$27",  "$28",  "$29",  "$30",  "$31"
 337 };
 338
 339 struct mips_abi_choice
 340 {
 341   const char * name;
 342   const char * const *gpr_names;
 343   const char * const *fpr_names;
 344 };
 345
 346 struct mips_abi_choice mips_abi_choices[] =
 347 {
 348   { "numeric", mips_gpr_names_numeric, mips_fpr_names_numeric },
 349   { "32", mips_gpr_names_oldabi, mips_fpr_names_32 },
 350   { "n32", mips_gpr_names_newabi, mips_fpr_names_n32 },
 351   { "64", mips_gpr_names_newabi, mips_fpr_names_64 },
 352 };
 353
 354 struct mips_arch_choice
 355 {
 356   const char *name;
 357   int bfd_mach_valid;
 358   unsigned long bfd_mach;
 359   int processor;
 360   int isa;
 361   const char * const *cp0_names;
 362   const struct mips_cp0sel_name *cp0sel_names;
 363   unsigned int cp0sel_names_len;
 364   const char * const *hwr_names;
 365 };
 366
 367 const struct mips_arch_choice mips_arch_choices[] =
 368 {
 369   { "numeric",  0, 0, 0, 0,
 370     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 371
 372   { "r3000",    1, bfd_mach_mips3000, CPU_R3000, ISA_MIPS1,
 373     mips_cp0_names_r3000, NULL, 0, mips_hwr_names_numeric },
 374   { "r3900",    1, bfd_mach_mips3900, CPU_R3900, ISA_MIPS1,
 375     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 376   { "r4000",    1, bfd_mach_mips4000, CPU_R4000, ISA_MIPS3,
 377     mips_cp0_names_r4000, NULL, 0, mips_hwr_names_numeric },
 378   { "r4010",    1, bfd_mach_mips4010, CPU_R4010, ISA_MIPS2,
 379     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 380   { "vr4100",   1, bfd_mach_mips4100, CPU_VR4100, ISA_MIPS3,
 381     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 382   { "vr4111",   1, bfd_mach_mips4111, CPU_R4111, ISA_MIPS3,
 383     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 384   { "vr4120",   1, bfd_mach_mips4120, CPU_VR4120, ISA_MIPS3,
 385     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 386   { "r4300",    1, bfd_mach_mips4300, CPU_R4300, ISA_MIPS3,
 387     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 388   { "r4400",    1, bfd_mach_mips4400, CPU_R4400, ISA_MIPS3,
 389     mips_cp0_names_r4000, NULL, 0, mips_hwr_names_numeric },
 390   { "r4600",    1, bfd_mach_mips4600, CPU_R4600, ISA_MIPS3,
 391     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 392   { "r4650",    1, bfd_mach_mips4650, CPU_R4650, ISA_MIPS3,
 393     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 394   { "r5000",    1, bfd_mach_mips5000, CPU_R5000, ISA_MIPS4,
 395     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 396   { "vr5400",   1, bfd_mach_mips5400, CPU_VR5400, ISA_MIPS4,
 397     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 398   { "vr5500",   1, bfd_mach_mips5500, CPU_VR5500, ISA_MIPS4,
 399     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 400   { "r6000",    1, bfd_mach_mips6000, CPU_R6000, ISA_MIPS2,
 401     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 402   { "rm7000",   1, bfd_mach_mips7000, CPU_RM7000, ISA_MIPS4,
 403     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 404   { "rm9000",   1, bfd_mach_mips7000, CPU_RM7000, ISA_MIPS4,
 405     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 406   { "r8000",    1, bfd_mach_mips8000, CPU_R8000, ISA_MIPS4,
 407     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 408   { "r10000",   1, bfd_mach_mips10000, CPU_R10000, ISA_MIPS4,
 409     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 410   { "r12000",   1, bfd_mach_mips12000, CPU_R12000, ISA_MIPS4,
 411     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 412   { "mips5",    1, bfd_mach_mips5, CPU_MIPS5, ISA_MIPS5,
 413     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 414
 415   /* For stock MIPS32, disassemble all applicable MIPS-specified ASEs.
 416      Note that MIPS-3D and MDMX are not applicable to MIPS32.  (See
 417      _MIPS32 Architecture For Programmers Volume I: Introduction to the
 418      MIPS32 Architecture_ (MIPS Document Number MD00082, Revision 0.95),
 419      page 1.  */
 420   { "mips32",   1, bfd_mach_mipsisa32, CPU_MIPS32,
 421     ISA_MIPS32 | INSN_MIPS16 | INSN_SMARTMIPS,
 422     mips_cp0_names_mips3264,
 423     mips_cp0sel_names_mips3264, ARRAY_SIZE (mips_cp0sel_names_mips3264),
 424     mips_hwr_names_numeric },
 425
 426   { "mips32r2", 1, bfd_mach_mipsisa32r2, CPU_MIPS32R2,
 427     (ISA_MIPS32R2 | INSN_MIPS16 | INSN_SMARTMIPS | INSN_DSP | INSN_DSPR2
 428      | INSN_MIPS3D | INSN_MT),
 429     mips_cp0_names_mips3264r2,
 430     mips_cp0sel_names_mips3264r2, ARRAY_SIZE (mips_cp0sel_names_mips3264r2),
 431     mips_hwr_names_mips3264r2 },
 432
 433   /* For stock MIPS64, disassemble all applicable MIPS-specified ASEs.  */
 434   { "mips64",   1, bfd_mach_mipsisa64, CPU_MIPS64,
 435     ISA_MIPS64 | INSN_MIPS16 | INSN_MIPS3D | INSN_MDMX,
 436     mips_cp0_names_mips3264,
 437     mips_cp0sel_names_mips3264, ARRAY_SIZE (mips_cp0sel_names_mips3264),
 438     mips_hwr_names_numeric },
 439
 440   { "mips64r2", 1, bfd_mach_mipsisa64r2, CPU_MIPS64R2,
 441     (ISA_MIPS64R2 | INSN_MIPS16 | INSN_MIPS3D | INSN_DSP | INSN_DSPR2
 442      | INSN_DSP64 | INSN_MT | INSN_MDMX),
 443     mips_cp0_names_mips3264r2,
 444     mips_cp0sel_names_mips3264r2, ARRAY_SIZE (mips_cp0sel_names_mips3264r2),
 445     mips_hwr_names_mips3264r2 },
 446
 447   { "sb1",      1, bfd_mach_mips_sb1, CPU_SB1,
 448     ISA_MIPS64 | INSN_MIPS3D | INSN_SB1,
 449     mips_cp0_names_sb1,
 450     mips_cp0sel_names_sb1, ARRAY_SIZE (mips_cp0sel_names_sb1),
 451     mips_hwr_names_numeric },
 452
 453   { "loongson2e",   1, bfd_mach_mips_loongson_2e, CPU_LOONGSON_2E,
 454     ISA_MIPS3 | INSN_LOONGSON_2E, mips_cp0_names_numeric,
 455     NULL, 0, mips_hwr_names_numeric },
 456
 457   { "loongson2f",   1, bfd_mach_mips_loongson_2f, CPU_LOONGSON_2F,
 458     ISA_MIPS3 | INSN_LOONGSON_2F, mips_cp0_names_numeric,
 459     NULL, 0, mips_hwr_names_numeric },
 460
 461   { "octeon",   1, bfd_mach_mips_octeon, CPU_OCTEON,
 462     ISA_MIPS64R2 | INSN_OCTEON, mips_cp0_names_numeric, NULL, 0,
 463     mips_hwr_names_numeric },
 464
 465   /* This entry, mips16, is here only for ISA/processor selection; do
 466      not print its name.  */
 467   { "",         1, bfd_mach_mips16, CPU_MIPS16, ISA_MIPS3 | INSN_MIPS16,
 468     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 469 };
 470
 471 /* ISA and processor type to disassemble for, and register names to use.
 472    set_default_mips_dis_options and parse_mips_dis_options fill in these
 473    values.  */
 474 static int mips_processor;
 475 static int mips_isa;
 476 static const char * const *mips_gpr_names;
 477 static const char * const *mips_fpr_names;
 478 static const char * const *mips_cp0_names;
 479 static const struct mips_cp0sel_name *mips_cp0sel_names;
 480 static int mips_cp0sel_names_len;
 481 static const char * const *mips_hwr_names;
 482
 483 /* Other options */
 484 static int no_aliases;  /* If set disassemble as most general inst.  */
 485 \f
 486 static const struct mips_abi_choice *
 487 choose_abi_by_name (const char *name, unsigned int namelen)
 488 {
 489   const struct mips_abi_choice *c;
 490   unsigned int i;
 491
 492   for (i = 0, c = NULL; i < ARRAY_SIZE (mips_abi_choices) && c == NULL; i++)
 493     if (strncmp (mips_abi_choices[i].name, name, namelen) == 0
 494         && strlen (mips_abi_choices[i].name) == namelen)
 495       c = &mips_abi_choices[i];
 496
 497   return c;
 498 }
 499
 500 static const struct mips_arch_choice *
 501 choose_arch_by_name (const char *name, unsigned int namelen)
 502 {
 503   const struct mips_arch_choice *c = NULL;
 504   unsigned int i;
 505
 506   for (i = 0, c = NULL; i < ARRAY_SIZE (mips_arch_choices) && c == NULL; i++)
 507     if (strncmp (mips_arch_choices[i].name, name, namelen) == 0
 508         && strlen (mips_arch_choices[i].name) == namelen)
 509       c = &mips_arch_choices[i];
 510
 511   return c;
 512 }
 513
 514 static const struct mips_arch_choice *
 515 choose_arch_by_number (unsigned long mach)
 516 {
 517   static unsigned long hint_bfd_mach;
 518   static const struct mips_arch_choice *hint_arch_choice;
 519   const struct mips_arch_choice *c;
 520   unsigned int i;
 521
 522   /* We optimize this because even if the user specifies no
 523      flags, this will be done for every instruction!  */
 524   if (hint_bfd_mach == mach
 525       && hint_arch_choice != NULL
 526       && hint_arch_choice->bfd_mach == hint_bfd_mach)
 527     return hint_arch_choice;
 528
 529   for (i = 0, c = NULL; i < ARRAY_SIZE (mips_arch_choices) && c == NULL; i++)
 530     {
 531       if (mips_arch_choices[i].bfd_mach_valid
 532           && mips_arch_choices[i].bfd_mach == mach)
 533         {
 534           c = &mips_arch_choices[i];
 535           hint_bfd_mach = mach;
 536           hint_arch_choice = c;
 537         }
 538     }
 539   return c;
 540 }
 541
 542 /* Check if the object uses NewABI conventions.  */
 543
 544 static int
 545 is_newabi (Elf_Internal_Ehdr *header)
 546 {
 547   /* There are no old-style ABIs which use 64-bit ELF.  */
 548   if (header->e_ident[EI_CLASS] == ELFCLASS64)
 549     return 1;
 550
 551   /* If a 32-bit ELF file, n32 is a new-style ABI.  */
 552   if ((header->e_flags & EF_MIPS_ABI2) != 0)
 553     return 1;
 554
 555   return 0;
 556 }
 557
 558 static void
 559 set_default_mips_dis_options (struct disassemble_info *info)
 560 {
 561   const struct mips_arch_choice *chosen_arch;
 562
 563   /* Defaults: mipsIII/r3000 (?!), (o)32-style ("oldabi") GPR names,
 564      and numeric FPR, CP0 register, and HWR names.  */
 565   mips_isa = ISA_MIPS3;
 566   mips_processor =  CPU_R3000;
 567   mips_gpr_names = mips_gpr_names_oldabi;
 568   mips_fpr_names = mips_fpr_names_numeric;
 569   mips_cp0_names = mips_cp0_names_numeric;
 570   mips_cp0sel_names = NULL;
 571   mips_cp0sel_names_len = 0;
 572   mips_hwr_names = mips_hwr_names_numeric;
 573   no_aliases = 0;
 574
 575   /* If an ELF "newabi" binary, use the n32/(n)64 GPR names.  */
 576   if (info->flavour == bfd_target_elf_flavour && info->section != NULL)
 577     {
 578       Elf_Internal_Ehdr *header;
 579
 580       header = elf_elfheader (info->section->owner);
 581       if (is_newabi (header))
 582         mips_gpr_names = mips_gpr_names_newabi;
 583     }
 584
 585   /* Set ISA, architecture, and cp0 register names as best we can.  */
 586 #if ! SYMTAB_AVAILABLE
 587   /* This is running out on a target machine, not in a host tool.
 588      FIXME: Where does mips_target_info come from?  */
 589   target_processor = mips_target_info.processor;
 590   mips_isa = mips_target_info.isa;
 591 #else
 592   chosen_arch = choose_arch_by_number (info->mach);
 593   if (chosen_arch != NULL)
 594     {
 595       mips_processor = chosen_arch->processor;
 596       mips_isa = chosen_arch->isa;
 597       mips_cp0_names = chosen_arch->cp0_names;
 598       mips_cp0sel_names = chosen_arch->cp0sel_names;
 599       mips_cp0sel_names_len = chosen_arch->cp0sel_names_len;
 600       mips_hwr_names = chosen_arch->hwr_names;
 601     }
 602 #endif
 603 }
 604
 605 static void
 606 parse_mips_dis_option (const char *option, unsigned int len)
 607 {
 608   unsigned int i, optionlen, vallen;
 609   const char *val;
 610   const struct mips_abi_choice *chosen_abi;
 611   const struct mips_arch_choice *chosen_arch;
 612
 613   /* Try to match options that are simple flags */
 614   if (CONST_STRNEQ (option, "no-aliases"))
 615     {
 616       no_aliases = 1;
 617       return;
 618     }
 619
 620   /* Look for the = that delimits the end of the option name.  */
 621   for (i = 0; i < len; i++)
 622     if (option[i] == '=')
 623       break;
 624
 625   if (i == 0)           /* Invalid option: no name before '='.  */
 626     return;
 627   if (i == len)         /* Invalid option: no '='.  */
 628     return;
 629   if (i == (len - 1))   /* Invalid option: no value after '='.  */
 630     return;
 631
 632   optionlen = i;
 633   val = option + (optionlen + 1);
 634   vallen = len - (optionlen + 1);
 635
 636   if (strncmp ("gpr-names", option, optionlen) == 0
 637       && strlen ("gpr-names") == optionlen)
 638     {
 639       chosen_abi = choose_abi_by_name (val, vallen);
 640       if (chosen_abi != NULL)
 641         mips_gpr_names = chosen_abi->gpr_names;
 642       return;
 643     }
 644
 645   if (strncmp ("fpr-names", option, optionlen) == 0
 646       && strlen ("fpr-names") == optionlen)
 647     {
 648       chosen_abi = choose_abi_by_name (val, vallen);
 649       if (chosen_abi != NULL)
 650         mips_fpr_names = chosen_abi->fpr_names;
 651       return;
 652     }
 653
 654   if (strncmp ("cp0-names", option, optionlen) == 0
 655       && strlen ("cp0-names") == optionlen)
 656     {
 657       chosen_arch = choose_arch_by_name (val, vallen);
 658       if (chosen_arch != NULL)
 659         {
 660           mips_cp0_names = chosen_arch->cp0_names;
 661           mips_cp0sel_names = chosen_arch->cp0sel_names;
 662           mips_cp0sel_names_len = chosen_arch->cp0sel_names_len;
 663         }
 664       return;
 665     }
 666
 667   if (strncmp ("hwr-names", option, optionlen) == 0
 668       && strlen ("hwr-names") == optionlen)
 669     {
 670       chosen_arch = choose_arch_by_name (val, vallen);
 671       if (chosen_arch != NULL)
 672         mips_hwr_names = chosen_arch->hwr_names;
 673       return;
 674     }
 675
 676   if (strncmp ("reg-names", option, optionlen) == 0
 677       && strlen ("reg-names") == optionlen)
 678     {
 679       /* We check both ABI and ARCH here unconditionally, so
 680          that "numeric" will do the desirable thing: select
 681          numeric register names for all registers.  Other than
 682          that, a given name probably won't match both.  */
 683       chosen_abi = choose_abi_by_name (val, vallen);
 684       if (chosen_abi != NULL)
 685         {
 686           mips_gpr_names = chosen_abi->gpr_names;
 687           mips_fpr_names = chosen_abi->fpr_names;
 688         }
 689       chosen_arch = choose_arch_by_name (val, vallen);
 690       if (chosen_arch != NULL)
 691         {
 692           mips_cp0_names = chosen_arch->cp0_names;
 693           mips_cp0sel_names = chosen_arch->cp0sel_names;
 694           mips_cp0sel_names_len = chosen_arch->cp0sel_names_len;
 695           mips_hwr_names = chosen_arch->hwr_names;
 696         }
 697       return;
 698     }
 699
 700   /* Invalid option.  */
 701 }
 702
 703 static void
 704 parse_mips_dis_options (const char *options)
 705 {
 706   const char *option_end;
 707
 708   if (options == NULL)
 709     return;
 710
 711   while (*options != '\0')
 712     {
 713       /* Skip empty options.  */
 714       if (*options == ',')
 715         {
 716           options++;
 717           continue;
 718         }
 719
 720       /* We know that *options is neither NUL or a comma.  */
 721       option_end = options + 1;
 722       while (*option_end != ',' && *option_end != '\0')
 723         option_end++;
 724
 725       parse_mips_dis_option (options, option_end - options);
 726
 727       /* Go on to the next one.  If option_end points to a comma, it
 728          will be skipped above.  */
 729       options = option_end;
 730     }
 731 }
 732
 733 static const struct mips_cp0sel_name *
 734 lookup_mips_cp0sel_name (const struct mips_cp0sel_name *names,
 735                          unsigned int len,
 736                          unsigned int cp0reg,
 737                          unsigned int sel)
 738 {
 739   unsigned int i;
 740
 741   for (i = 0; i < len; i++)
 742     if (names[i].cp0reg == cp0reg && names[i].sel == sel)
 743       return &names[i];
 744   return NULL;
 745 }
 746 \f
 747 /* Print insn arguments for 32/64-bit code.  */
 748
 749 static void
 750 print_insn_args (const char *d,
 751                  register unsigned long int l,
 752                  bfd_vma pc,
 753                  struct disassemble_info *info,
 754                  const struct mips_opcode *opp)
 755 {
 756   int op, delta;
 757   unsigned int lsb, msb, msbd;
 758
 759   lsb = 0;
 760
 761   for (; *d != '\0'; d++)
 762     {
 763       switch (*d)
 764         {
 765         case ',':
 766         case '(':
 767         case ')':
 768         case '[':
 769         case ']':
 770           (*info->fprintf_func) (info->stream, "%c", *d);
 771           break;
 772
 773         case '+':
 774           /* Extension character; switch for second char.  */
 775           d++;
 776           switch (*d)
 777             {
 778             case '\0':
 779               /* xgettext:c-format */
 780               (*info->fprintf_func) (info->stream,
 781                                      _("# internal error, incomplete extension sequence (+)"));
 782               return;
 783
 784             case 'A':
 785               lsb = (l >> OP_SH_SHAMT) & OP_MASK_SHAMT;
 786               (*info->fprintf_func) (info->stream, "0x%x", lsb);
 787               break;
 788
 789             case 'B':
 790               msb = (l >> OP_SH_INSMSB) & OP_MASK_INSMSB;
 791               (*info->fprintf_func) (info->stream, "0x%x", msb - lsb + 1);
 792               break;
 793
 794             case '1':
 795               (*info->fprintf_func) (info->stream, "0x%lx",
 796                                      (l >> OP_SH_UDI1) & OP_MASK_UDI1);
 797               break;
 798
 799             case '2':
 800               (*info->fprintf_func) (info->stream, "0x%lx",
 801                                      (l >> OP_SH_UDI2) & OP_MASK_UDI2);
 802               break;
 803
 804             case '3':
 805               (*info->fprintf_func) (info->stream, "0x%lx",
 806                                      (l >> OP_SH_UDI3) & OP_MASK_UDI3);
 807               break;
 808
 809             case '4':
 810               (*info->fprintf_func) (info->stream, "0x%lx",
 811                                      (l >> OP_SH_UDI4) & OP_MASK_UDI4);
 812               break;
 813
 814             case 'C':
 815             case 'H':
 816               msbd = (l >> OP_SH_EXTMSBD) & OP_MASK_EXTMSBD;
 817               (*info->fprintf_func) (info->stream, "0x%x", msbd + 1);
 818               break;
 819
 820             case 'D':
 821               {
 822                 const struct mips_cp0sel_name *n;
 823                 unsigned int cp0reg, sel;
 824
 825                 cp0reg = (l >> OP_SH_RD) & OP_MASK_RD;
 826                 sel = (l >> OP_SH_SEL) & OP_MASK_SEL;
 827
 828                 /* CP0 register including 'sel' code for mtcN (et al.), to be
 829                    printed textually if known.  If not known, print both
 830                    CP0 register name and sel numerically since CP0 register
 831                    with sel 0 may have a name unrelated to register being
 832                    printed.  */
 833                 n = lookup_mips_cp0sel_name(mips_cp0sel_names,
 834                                             mips_cp0sel_names_len, cp0reg, sel);
 835                 if (n != NULL)
 836                   (*info->fprintf_func) (info->stream, "%s", n->name);
 837                 else
 838                   (*info->fprintf_func) (info->stream, "$%d,%d", cp0reg, sel);
 839                 break;
 840               }
 841
 842             case 'E':
 843               lsb = ((l >> OP_SH_SHAMT) & OP_MASK_SHAMT) + 32;
 844               (*info->fprintf_func) (info->stream, "0x%x", lsb);
 845               break;
 846
 847             case 'F':
 848               msb = ((l >> OP_SH_INSMSB) & OP_MASK_INSMSB) + 32;
 849               (*info->fprintf_func) (info->stream, "0x%x", msb - lsb + 1);
 850               break;
 851
 852             case 'G':
 853               msbd = ((l >> OP_SH_EXTMSBD) & OP_MASK_EXTMSBD) + 32;
 854               (*info->fprintf_func) (info->stream, "0x%x", msbd + 1);
 855               break;
 856
 857             case 't': /* Coprocessor 0 reg name */
 858               (*info->fprintf_func) (info->stream, "%s",
 859                                      mips_cp0_names[(l >> OP_SH_RT) &
 860                                                      OP_MASK_RT]);
 861               break;
 862
 863             case 'T': /* Coprocessor 0 reg name */
 864               {
 865                 const struct mips_cp0sel_name *n;
 866                 unsigned int cp0reg, sel;
 867
 868                 cp0reg = (l >> OP_SH_RT) & OP_MASK_RT;
 869                 sel = (l >> OP_SH_SEL) & OP_MASK_SEL;
 870
 871                 /* CP0 register including 'sel' code for mftc0, to be
 872                    printed textually if known.  If not known, print both
 873                    CP0 register name and sel numerically since CP0 register
 874                    with sel 0 may have a name unrelated to register being
 875                    printed.  */
 876                 n = lookup_mips_cp0sel_name(mips_cp0sel_names,
 877                                             mips_cp0sel_names_len, cp0reg, sel);
 878                 if (n != NULL)
 879                   (*info->fprintf_func) (info->stream, "%s", n->name);
 880                 else
 881                   (*info->fprintf_func) (info->stream, "$%d,%d", cp0reg, sel);
 882                 break;
 883               }
 884
 885             case 'x':           /* bbit bit index */
 886               (*info->fprintf_func) (info->stream, "0x%lx",
 887                                      (l >> OP_SH_BBITIND) & OP_MASK_BBITIND);
 888               break;
 889
 890             case 'p':           /* cins, cins32, exts and exts32 position */
 891               (*info->fprintf_func) (info->stream, "0x%lx",
 892                                      (l >> OP_SH_CINSPOS) & OP_MASK_CINSPOS);
 893               break;
 894
 895             case 's':           /* cins and exts length-minus-one */
 896               (*info->fprintf_func) (info->stream, "0x%lx",
 897                                      (l >> OP_SH_CINSLM1) & OP_MASK_CINSLM1);
 898               break;
 899
 900             case 'S':           /* cins32 and exts32 length-minus-one field */
 901               (*info->fprintf_func) (info->stream, "0x%lx",
 902                                      (l >> OP_SH_CINSLM1) & OP_MASK_CINSLM1);
 903               break;
 904
 905             case 'Q':           /* seqi/snei immediate field */
 906               op = (l >> OP_SH_SEQI) & OP_MASK_SEQI;
 907               /* Sign-extend it.  */
 908               op = (op ^ 512) - 512;
 909               (*info->fprintf_func) (info->stream, "%d", op);
 910               break;
 911
 912             default:
 913               /* xgettext:c-format */
 914               (*info->fprintf_func) (info->stream,
 915                                      _("# internal error, undefined extension sequence (+%c)"),
 916                                      *d);
 917               return;
 918             }
 919           break;
 920
 921         case '2':
 922           (*info->fprintf_func) (info->stream, "0x%lx",
 923                                  (l >> OP_SH_BP) & OP_MASK_BP);
 924           break;
 925
 926         case '3':
 927           (*info->fprintf_func) (info->stream, "0x%lx",
 928                                  (l >> OP_SH_SA3) & OP_MASK_SA3);
 929           break;
 930
 931         case '4':
 932           (*info->fprintf_func) (info->stream, "0x%lx",
 933                                  (l >> OP_SH_SA4) & OP_MASK_SA4);
 934           break;
 935
 936         case '5':
 937           (*info->fprintf_func) (info->stream, "0x%lx",
 938                                  (l >> OP_SH_IMM8) & OP_MASK_IMM8);
 939           break;
 940
 941         case '6':
 942           (*info->fprintf_func) (info->stream, "0x%lx",
 943                                  (l >> OP_SH_RS) & OP_MASK_RS);
 944           break;
 945
 946         case '7':
 947           (*info->fprintf_func) (info->stream, "$ac%ld",
 948                                  (l >> OP_SH_DSPACC) & OP_MASK_DSPACC);
 949           break;
 950
 951         case '8':
 952           (*info->fprintf_func) (info->stream, "0x%lx",
 953                                  (l >> OP_SH_WRDSP) & OP_MASK_WRDSP);
 954           break;
 955
 956         case '9':
 957           (*info->fprintf_func) (info->stream, "$ac%ld",
 958                                  (l >> OP_SH_DSPACC_S) & OP_MASK_DSPACC_S);
 959           break;
 960
 961         case '0': /* dsp 6-bit signed immediate in bit 20 */
 962           delta = ((l >> OP_SH_DSPSFT) & OP_MASK_DSPSFT);
 963           if (delta & 0x20) /* test sign bit */
 964             delta |= ~OP_MASK_DSPSFT;
 965           (*info->fprintf_func) (info->stream, "%d", delta);
 966           break;
 967
 968         case ':': /* dsp 7-bit signed immediate in bit 19 */
 969           delta = ((l >> OP_SH_DSPSFT_7) & OP_MASK_DSPSFT_7);
 970           if (delta & 0x40) /* test sign bit */
 971             delta |= ~OP_MASK_DSPSFT_7;
 972           (*info->fprintf_func) (info->stream, "%d", delta);
 973           break;
 974
 975         case '\'':
 976           (*info->fprintf_func) (info->stream, "0x%lx",
 977                                  (l >> OP_SH_RDDSP) & OP_MASK_RDDSP);
 978           break;
 979
 980         case '@': /* dsp 10-bit signed immediate in bit 16 */
 981           delta = ((l >> OP_SH_IMM10) & OP_MASK_IMM10);
 982           if (delta & 0x200) /* test sign bit */
 983             delta |= ~OP_MASK_IMM10;
 984           (*info->fprintf_func) (info->stream, "%d", delta);
 985           break;
 986
 987         case '!':
 988           (*info->fprintf_func) (info->stream, "%ld",
 989                                  (l >> OP_SH_MT_U) & OP_MASK_MT_U);
 990           break;
 991
 992         case '$':
 993           (*info->fprintf_func) (info->stream, "%ld",
 994                                  (l >> OP_SH_MT_H) & OP_MASK_MT_H);
 995           break;
 996
 997         case '*':
 998           (*info->fprintf_func) (info->stream, "$ac%ld",
 999                                  (l >> OP_SH_MTACC_T) & OP_MASK_MTACC_T);
1000           break;
1001
1002         case '&':
1003           (*info->fprintf_func) (info->stream, "$ac%ld",
1004                                  (l >> OP_SH_MTACC_D) & OP_MASK_MTACC_D);
1005           break;
1006
1007         case 'g':
1008           /* Coprocessor register for CTTC1, MTTC2, MTHC2, CTTC2.  */
1009           (*info->fprintf_func) (info->stream, "$%ld",
1010                                  (l >> OP_SH_RD) & OP_MASK_RD);
1011           break;
1012
1013         case 's':
1014         case 'b':
1015         case 'r':
1016         case 'v':
1017           (*info->fprintf_func) (info->stream, "%s",
1018                                  mips_gpr_names[(l >> OP_SH_RS) & OP_MASK_RS]);
1019           break;
1020
1021         case 't':
1022         case 'w':
1023           (*info->fprintf_func) (info->stream, "%s",
1024                                  mips_gpr_names[(l >> OP_SH_RT) & OP_MASK_RT]);
1025           break;
1026
1027         case 'i':
1028         case 'u':
1029           (*info->fprintf_func) (info->stream, "0x%lx",
1030                                  (l >> OP_SH_IMMEDIATE) & OP_MASK_IMMEDIATE);
1031           break;
1032
1033         case 'j': /* Same as i, but sign-extended.  */
1034         case 'o':
1035           delta = (l >> OP_SH_DELTA) & OP_MASK_DELTA;
1036           if (delta & 0x8000)
1037             delta |= ~0xffff;
1038           (*info->fprintf_func) (info->stream, "%d",
1039                                  delta);
1040           break;
1041
1042         case 'h':
1043           (*info->fprintf_func) (info->stream, "0x%x",
1044                                  (unsigned int) ((l >> OP_SH_PREFX)
1045                                                  & OP_MASK_PREFX));
1046           break;
1047
1048         case 'k':
1049           (*info->fprintf_func) (info->stream, "0x%x",
1050                                  (unsigned int) ((l >> OP_SH_CACHE)
1051                                                  & OP_MASK_CACHE));
1052           break;
1053
1054         case 'a':
1055           info->target = (((pc + 4) & ~(bfd_vma) 0x0fffffff)
1056                           | (((l >> OP_SH_TARGET) & OP_MASK_TARGET) << 2));
1057           /* For gdb disassembler, force odd address on jalx.  */
1058           if (info->flavour == bfd_target_unknown_flavour
1059               && strcmp (opp->name, "jalx") == 0)
1060             info->target |= 1;
1061           (*info->print_address_func) (info->target, info);
1062           break;
1063
1064         case 'p':
1065           /* Sign extend the displacement.  */
1066           delta = (l >> OP_SH_DELTA) & OP_MASK_DELTA;
1067           if (delta & 0x8000)
1068             delta |= ~0xffff;
1069           info->target = (delta << 2) + pc + INSNLEN;
1070           (*info->print_address_func) (info->target, info);
1071           break;
1072
1073         case 'd':
1074           (*info->fprintf_func) (info->stream, "%s",
1075                                  mips_gpr_names[(l >> OP_SH_RD) & OP_MASK_RD]);
1076           break;
1077
1078         case 'U':
1079           {
1080             /* First check for both rd and rt being equal.  */
1081             unsigned int reg = (l >> OP_SH_RD) & OP_MASK_RD;
1082             if (reg == ((l >> OP_SH_RT) & OP_MASK_RT))
1083               (*info->fprintf_func) (info->stream, "%s",
1084                                      mips_gpr_names[reg]);
1085             else
1086               {
1087                 /* If one is zero use the other.  */
1088                 if (reg == 0)
1089                   (*info->fprintf_func) (info->stream, "%s",
1090                                          mips_gpr_names[(l >> OP_SH_RT) & OP_MASK_RT]);
1091                 else if (((l >> OP_SH_RT) & OP_MASK_RT) == 0)
1092                   (*info->fprintf_func) (info->stream, "%s",
1093                                          mips_gpr_names[reg]);
1094                 else /* Bogus, result depends on processor.  */
1095                   (*info->fprintf_func) (info->stream, "%s or %s",
1096                                          mips_gpr_names[reg],
1097                                          mips_gpr_names[(l >> OP_SH_RT) & OP_MASK_RT]);
1098               }
1099           }
1100           break;
1101
1102         case 'z':
1103           (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[0]);
1104           break;
1105
1106         case '<':
1107         case '1':
1108           (*info->fprintf_func) (info->stream, "0x%lx",
1109                                  (l >> OP_SH_SHAMT) & OP_MASK_SHAMT);
1110           break;
1111
1112         case 'c':
1113           (*info->fprintf_func) (info->stream, "0x%lx",
1114                                  (l >> OP_SH_CODE) & OP_MASK_CODE);
1115           break;
1116
1117         case 'q':
1118           (*info->fprintf_func) (info->stream, "0x%lx",
1119                                  (l >> OP_SH_CODE2) & OP_MASK_CODE2);
1120           break;
1121
1122         case 'C':
1123           (*info->fprintf_func) (info->stream, "0x%lx",
1124                                  (l >> OP_SH_COPZ) & OP_MASK_COPZ);
1125           break;
1126
1127         case 'B':
1128           (*info->fprintf_func) (info->stream, "0x%lx",
1129
1130                                  (l >> OP_SH_CODE20) & OP_MASK_CODE20);
1131           break;
1132
1133         case 'J':
1134           (*info->fprintf_func) (info->stream, "0x%lx",
1135                                  (l >> OP_SH_CODE19) & OP_MASK_CODE19);
1136           break;
1137
1138         case 'S':
1139         case 'V':
1140           (*info->fprintf_func) (info->stream, "%s",
1141                                  mips_fpr_names[(l >> OP_SH_FS) & OP_MASK_FS]);
1142           break;
1143
1144         case 'T':
1145         case 'W':
1146           (*info->fprintf_func) (info->stream, "%s",
1147                                  mips_fpr_names[(l >> OP_SH_FT) & OP_MASK_FT]);
1148           break;
1149
1150         case 'D':
1151           (*info->fprintf_func) (info->stream, "%s",
1152                                  mips_fpr_names[(l >> OP_SH_FD) & OP_MASK_FD]);
1153           break;
1154
1155         case 'R':
1156           (*info->fprintf_func) (info->stream, "%s",
1157                                  mips_fpr_names[(l >> OP_SH_FR) & OP_MASK_FR]);
1158           break;
1159
1160         case 'E':
1161           /* Coprocessor register for lwcN instructions, et al.
1162
1163              Note that there is no load/store cp0 instructions, and
1164              that FPU (cp1) instructions disassemble this field using
1165              'T' format.  Therefore, until we gain understanding of
1166              cp2 register names, we can simply print the register
1167              numbers.  */
1168           (*info->fprintf_func) (info->stream, "$%ld",
1169                                  (l >> OP_SH_RT) & OP_MASK_RT);
1170           break;
1171
1172         case 'G':
1173           /* Coprocessor register for mtcN instructions, et al.  Note
1174              that FPU (cp1) instructions disassemble this field using
1175              'S' format.  Therefore, we only need to worry about cp0,
1176              cp2, and cp3.  */
1177           op = (l >> OP_SH_OP) & OP_MASK_OP;
1178           if (op == OP_OP_COP0)
1179             (*info->fprintf_func) (info->stream, "%s",
1180                                    mips_cp0_names[(l >> OP_SH_RD) & OP_MASK_RD]);
1181           else
1182             (*info->fprintf_func) (info->stream, "$%ld",
1183                                    (l >> OP_SH_RD) & OP_MASK_RD);
1184           break;
1185
1186         case 'K':
1187           (*info->fprintf_func) (info->stream, "%s",
1188                                  mips_hwr_names[(l >> OP_SH_RD) & OP_MASK_RD]);
1189           break;
1190
1191         case 'N':
1192           (*info->fprintf_func) (info->stream,
1193                                  ((opp->pinfo & (FP_D | FP_S)) != 0
1194                                   ? "$fcc%ld" : "$cc%ld"),
1195                                  (l >> OP_SH_BCC) & OP_MASK_BCC);
1196           break;
1197
1198         case 'M':
1199           (*info->fprintf_func) (info->stream, "$fcc%ld",
1200                                  (l >> OP_SH_CCC) & OP_MASK_CCC);
1201           break;
1202
1203         case 'P':
1204           (*info->fprintf_func) (info->stream, "%ld",
1205                                  (l >> OP_SH_PERFREG) & OP_MASK_PERFREG);
1206           break;
1207
1208         case 'e':
1209           (*info->fprintf_func) (info->stream, "%ld",
1210                                  (l >> OP_SH_VECBYTE) & OP_MASK_VECBYTE);
1211           break;
1212
1213         case '%':
1214           (*info->fprintf_func) (info->stream, "%ld",
1215                                  (l >> OP_SH_VECALIGN) & OP_MASK_VECALIGN);
1216           break;
1217
1218         case 'H':
1219           (*info->fprintf_func) (info->stream, "%ld",
1220                                  (l >> OP_SH_SEL) & OP_MASK_SEL);
1221           break;
1222
1223         case 'O':
1224           (*info->fprintf_func) (info->stream, "%ld",
1225                                  (l >> OP_SH_ALN) & OP_MASK_ALN);
1226           break;
1227
1228         case 'Q':
1229           {
1230             unsigned int vsel = (l >> OP_SH_VSEL) & OP_MASK_VSEL;
1231
1232             if ((vsel & 0x10) == 0)
1233               {
1234                 int fmt;
1235
1236                 vsel &= 0x0f;
1237                 for (fmt = 0; fmt < 3; fmt++, vsel >>= 1)
1238                   if ((vsel & 1) == 0)
1239                     break;
1240                 (*info->fprintf_func) (info->stream, "$v%ld[%d]",
1241                                        (l >> OP_SH_FT) & OP_MASK_FT,
1242                                        vsel >> 1);
1243               }
1244             else if ((vsel & 0x08) == 0)
1245               {
1246                 (*info->fprintf_func) (info->stream, "$v%ld",
1247                                        (l >> OP_SH_FT) & OP_MASK_FT);
1248               }
1249             else
1250               {
1251                 (*info->fprintf_func) (info->stream, "0x%lx",
1252                                        (l >> OP_SH_FT) & OP_MASK_FT);
1253               }
1254           }
1255           break;
1256
1257         case 'X':
1258           (*info->fprintf_func) (info->stream, "$v%ld",
1259                                  (l >> OP_SH_FD) & OP_MASK_FD);
1260           break;
1261
1262         case 'Y':
1263           (*info->fprintf_func) (info->stream, "$v%ld",
1264                                  (l >> OP_SH_FS) & OP_MASK_FS);
1265           break;
1266
1267         case 'Z':
1268           (*info->fprintf_func) (info->stream, "$v%ld",
1269                                  (l >> OP_SH_FT) & OP_MASK_FT);
1270           break;
1271
1272         default:
1273           /* xgettext:c-format */
1274           (*info->fprintf_func) (info->stream,
1275                                  _("# internal error, undefined modifier (%c)"),
1276                                  *d);
1277           return;
1278         }
1279     }
1280 }
1281 \f
1282 /* Print the mips instruction at address MEMADDR in debugged memory,
1283    on using INFO.  Returns length of the instruction, in bytes, which is
1284    always INSNLEN.  BIGENDIAN must be 1 if this is big-endian code, 0 if
1285    this is little-endian code.  */
1286
1287 static int
1288 print_insn_mips (bfd_vma memaddr,
1289                  unsigned long int word,
1290                  struct disassemble_info *info)
1291 {
1292   const struct mips_opcode *op;
1293   static bfd_boolean init = 0;
1294   static const struct mips_opcode *mips_hash[OP_MASK_OP + 1];
1295
1296   /* Build a hash table to shorten the search time.  */
1297   if (! init)
1298     {
1299       unsigned int i;
1300
1301       for (i = 0; i <= OP_MASK_OP; i++)
1302         {
1303           for (op = mips_opcodes; op < &mips_opcodes[NUMOPCODES]; op++)
1304             {
1305               if (op->pinfo == INSN_MACRO
1306                   || (no_aliases && (op->pinfo2 & INSN2_ALIAS)))
1307                 continue;
1308               if (i == ((op->match >> OP_SH_OP) & OP_MASK_OP))
1309                 {
1310                   mips_hash[i] = op;
1311                   break;
1312                 }
1313             }
1314         }
1315
1316       init = 1;
1317     }
1318
1319   info->bytes_per_chunk = INSNLEN;
1320   info->display_endian = info->endian;
1321   info->insn_info_valid = 1;
1322   info->branch_delay_insns = 0;
1323   info->data_size = 0;
1324   info->insn_type = dis_nonbranch;
1325   info->target = 0;
1326   info->target2 = 0;
1327
1328   op = mips_hash[(word >> OP_SH_OP) & OP_MASK_OP];
1329   if (op != NULL)
1330     {
1331       for (; op < &mips_opcodes[NUMOPCODES]; op++)
1332         {
1333           if (op->pinfo != INSN_MACRO
1334               && !(no_aliases && (op->pinfo2 & INSN2_ALIAS))
1335               && (word & op->mask) == op->match)
1336             {
1337               const char *d;
1338
1339               /* We always allow to disassemble the jalx instruction.  */
1340               if (! OPCODE_IS_MEMBER (op, mips_isa, mips_processor)
1341                   && strcmp (op->name, "jalx"))
1342                 continue;
1343
1344               /* Figure out instruction type and branch delay information.  */
1345               if ((op->pinfo & INSN_UNCOND_BRANCH_DELAY) != 0)
1346                 {
1347                   if ((info->insn_type & INSN_WRITE_GPR_31) != 0)
1348                     info->insn_type = dis_jsr;
1349                   else
1350                     info->insn_type = dis_branch;
1351                   info->branch_delay_insns = 1;
1352                 }
1353               else if ((op->pinfo & (INSN_COND_BRANCH_DELAY
1354                                      | INSN_COND_BRANCH_LIKELY)) != 0)
1355                 {
1356                   if ((info->insn_type & INSN_WRITE_GPR_31) != 0)
1357                     info->insn_type = dis_condjsr;
1358                   else
1359                     info->insn_type = dis_condbranch;
1360                   info->branch_delay_insns = 1;
1361                 }
1362               else if ((op->pinfo & (INSN_STORE_MEMORY
1363                                      | INSN_LOAD_MEMORY_DELAY)) != 0)
1364                 info->insn_type = dis_dref;
1365
1366               (*info->fprintf_func) (info->stream, "%s", op->name);
1367
1368               d = op->args;
1369               if (d != NULL && *d != '\0')
1370                 {
1371                   (*info->fprintf_func) (info->stream, "\t");
1372                   print_insn_args (d, word, memaddr, info, op);
1373                 }
1374
1375               return INSNLEN;
1376             }
1377         }
1378     }
1379
1380   /* Handle undefined instructions.  */
1381   info->insn_type = dis_noninsn;
1382   (*info->fprintf_func) (info->stream, "0x%lx", word);
1383   return INSNLEN;
1384 }
1385 \f
1386 /* Disassemble an operand for a mips16 instruction.  */
1387
1388 static void
1389 print_mips16_insn_arg (char type,
1390                        const struct mips_opcode *op,
1391                        int l,
1392                        bfd_boolean use_extend,
1393                        int extend,
1394                        bfd_vma memaddr,
1395                        struct disassemble_info *info)
1396 {
1397   switch (type)
1398     {
1399     case ',':
1400     case '(':
1401     case ')':
1402       (*info->fprintf_func) (info->stream, "%c", type);
1403       break;
1404
1405     case 'y':
1406     case 'w':
1407       (*info->fprintf_func) (info->stream, "%s",
1408                              mips16_reg_names(((l >> MIPS16OP_SH_RY)
1409                                                & MIPS16OP_MASK_RY)));
1410       break;
1411
1412     case 'x':
1413     case 'v':
1414       (*info->fprintf_func) (info->stream, "%s",
1415                              mips16_reg_names(((l >> MIPS16OP_SH_RX)
1416                                                & MIPS16OP_MASK_RX)));
1417       break;
1418
1419     case 'z':
1420       (*info->fprintf_func) (info->stream, "%s",
1421                              mips16_reg_names(((l >> MIPS16OP_SH_RZ)
1422                                                & MIPS16OP_MASK_RZ)));
1423       break;
1424
1425     case 'Z':
1426       (*info->fprintf_func) (info->stream, "%s",
1427                              mips16_reg_names(((l >> MIPS16OP_SH_MOVE32Z)
1428                                                & MIPS16OP_MASK_MOVE32Z)));
1429       break;
1430
1431     case '0':
1432       (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[0]);
1433       break;
1434
1435     case 'S':
1436       (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[29]);
1437       break;
1438
1439     case 'P':
1440       (*info->fprintf_func) (info->stream, "$pc");
1441       break;
1442
1443     case 'R':
1444       (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[31]);
1445       break;
1446
1447     case 'X':
1448       (*info->fprintf_func) (info->stream, "%s",
1449                              mips_gpr_names[((l >> MIPS16OP_SH_REGR32)
1450                                             & MIPS16OP_MASK_REGR32)]);
1451       break;
1452
1453     case 'Y':
1454       (*info->fprintf_func) (info->stream, "%s",
1455                              mips_gpr_names[MIPS16OP_EXTRACT_REG32R (l)]);
1456       break;
1457
1458     case '<':
1459     case '>':
1460     case '[':
1461     case ']':
1462     case '4':
1463     case '5':
1464     case 'H':
1465     case 'W':
1466     case 'D':
1467     case 'j':
1468     case '6':
1469     case '8':
1470     case 'V':
1471     case 'C':
1472     case 'U':
1473     case 'k':
1474     case 'K':
1475     case 'p':
1476     case 'q':
1477     case 'A':
1478     case 'B':
1479     case 'E':
1480       {
1481         int immed, nbits, shift, signedp, extbits, pcrel, extu, branch;
1482
1483         shift = 0;
1484         signedp = 0;
1485         extbits = 16;
1486         pcrel = 0;
1487         extu = 0;
1488         branch = 0;
1489         switch (type)
1490           {
1491           case '<':
1492             nbits = 3;
1493             immed = (l >> MIPS16OP_SH_RZ) & MIPS16OP_MASK_RZ;
1494             extbits = 5;
1495             extu = 1;
1496             break;
1497           case '>':
1498             nbits = 3;
1499             immed = (l >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX;
1500             extbits = 5;
1501             extu = 1;
1502             break;
1503           case '[':
1504             nbits = 3;
1505             immed = (l >> MIPS16OP_SH_RZ) & MIPS16OP_MASK_RZ;
1506             extbits = 6;
1507             extu = 1;
1508             break;
1509           case ']':
1510             nbits = 3;
1511             immed = (l >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX;
1512             extbits = 6;
1513             extu = 1;
1514             break;
1515           case '4':
1516             nbits = 4;
1517             immed = (l >> MIPS16OP_SH_IMM4) & MIPS16OP_MASK_IMM4;
1518             signedp = 1;
1519             extbits = 15;
1520             break;
1521           case '5':
1522             nbits = 5;
1523             immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1524             info->insn_type = dis_dref;
1525             info->data_size = 1;
1526             break;
1527           case 'H':
1528             nbits = 5;
1529             shift = 1;
1530             immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1531             info->insn_type = dis_dref;
1532             info->data_size = 2;
1533             break;
1534           case 'W':
1535             nbits = 5;
1536             shift = 2;
1537             immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1538             if ((op->pinfo & MIPS16_INSN_READ_PC) == 0
1539                 && (op->pinfo & MIPS16_INSN_READ_SP) == 0)
1540               {
1541                 info->insn_type = dis_dref;
1542                 info->data_size = 4;
1543               }
1544             break;
1545           case 'D':
1546             nbits = 5;
1547             shift = 3;
1548             immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1549             info->insn_type = dis_dref;
1550             info->data_size = 8;
1551             break;
1552           case 'j':
1553             nbits = 5;
1554             immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1555             signedp = 1;
1556             break;
1557           case '6':
1558             nbits = 6;
1559             immed = (l >> MIPS16OP_SH_IMM6) & MIPS16OP_MASK_IMM6;
1560             break;
1561           case '8':
1562             nbits = 8;
1563             immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1564             break;
1565           case 'V':
1566             nbits = 8;
1567             shift = 2;
1568             immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1569             /* FIXME: This might be lw, or it might be addiu to $sp or
1570                $pc.  We assume it's load.  */
1571             info->insn_type = dis_dref;
1572             info->data_size = 4;
1573             break;
1574           case 'C':
1575             nbits = 8;
1576             shift = 3;
1577             immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1578             info->insn_type = dis_dref;
1579             info->data_size = 8;
1580             break;
1581           case 'U':
1582             nbits = 8;
1583             immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1584             extu = 1;
1585             break;
1586           case 'k':
1587             nbits = 8;
1588             immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1589             signedp = 1;
1590             break;
1591           case 'K':
1592             nbits = 8;
1593             shift = 3;
1594             immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1595             signedp = 1;
1596             break;
1597           case 'p':
1598             nbits = 8;
1599             immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1600             signedp = 1;
1601             pcrel = 1;
1602             branch = 1;
1603             info->insn_type = dis_condbranch;
1604             break;
1605           case 'q':
1606             nbits = 11;
1607             immed = (l >> MIPS16OP_SH_IMM11) & MIPS16OP_MASK_IMM11;
1608             signedp = 1;
1609             pcrel = 1;
1610             branch = 1;
1611             info->insn_type = dis_branch;
1612             break;
1613           case 'A':
1614             nbits = 8;
1615             shift = 2;
1616             immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1617             pcrel = 1;
1618             /* FIXME: This can be lw or la.  We assume it is lw.  */
1619             info->insn_type = dis_dref;
1620             info->data_size = 4;
1621             break;
1622           case 'B':
1623             nbits = 5;
1624             shift = 3;
1625             immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1626             pcrel = 1;
1627             info->insn_type = dis_dref;
1628             info->data_size = 8;
1629             break;
1630           case 'E':
1631             nbits = 5;
1632             shift = 2;
1633             immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1634             pcrel = 1;
1635             break;
1636           default:
1637             abort ();
1638           }
1639
1640         if (! use_extend)
1641           {
1642             if (signedp && immed >= (1 << (nbits - 1)))
1643               immed -= 1 << nbits;
1644             immed <<= shift;
1645             if ((type == '<' || type == '>' || type == '[' || type == ']')
1646                 && immed == 0)
1647               immed = 8;
1648           }
1649         else
1650           {
1651             if (extbits == 16)
1652               immed |= ((extend & 0x1f) << 11) | (extend & 0x7e0);
1653             else if (extbits == 15)
1654               immed |= ((extend & 0xf) << 11) | (extend & 0x7f0);
1655             else
1656               immed = ((extend >> 6) & 0x1f) | (extend & 0x20);
1657             immed &= (1 << extbits) - 1;
1658             if (! extu && immed >= (1 << (extbits - 1)))
1659               immed -= 1 << extbits;
1660           }
1661
1662         if (! pcrel)
1663           (*info->fprintf_func) (info->stream, "%d", immed);
1664         else
1665           {
1666             bfd_vma baseaddr;
1667
1668             if (branch)
1669               {
1670                 immed *= 2;
1671                 baseaddr = memaddr + 2;
1672               }
1673             else if (use_extend)
1674               baseaddr = memaddr - 2;
1675             else
1676               {
1677                 int status;
1678                 bfd_byte buffer[2];
1679
1680                 baseaddr = memaddr;
1681
1682                 /* If this instruction is in the delay slot of a jr
1683                    instruction, the base address is the address of the
1684                    jr instruction.  If it is in the delay slot of jalr
1685                    instruction, the base address is the address of the
1686                    jalr instruction.  This test is unreliable: we have
1687                    no way of knowing whether the previous word is
1688                    instruction or data.  */
1689                 status = (*info->read_memory_func) (memaddr - 4, buffer, 2,
1690                                                     info);
1691                 if (status == 0
1692                     && (((info->endian == BFD_ENDIAN_BIG
1693                           ? bfd_getb16 (buffer)
1694                           : bfd_getl16 (buffer))
1695                          & 0xf800) == 0x1800))
1696                   baseaddr = memaddr - 4;
1697                 else
1698                   {
1699                     status = (*info->read_memory_func) (memaddr - 2, buffer,
1700                                                         2, info);
1701                     if (status == 0
1702                         && (((info->endian == BFD_ENDIAN_BIG
1703                               ? bfd_getb16 (buffer)
1704                               : bfd_getl16 (buffer))
1705                              & 0xf81f) == 0xe800))
1706                       baseaddr = memaddr - 2;
1707                   }
1708               }
1709             info->target = (baseaddr & ~((1 << shift) - 1)) + immed;
1710             if (pcrel && branch
1711                 && info->flavour == bfd_target_unknown_flavour)
1712               /* For gdb disassembler, maintain odd address.  */
1713               info->target |= 1;
1714             (*info->print_address_func) (info->target, info);
1715           }
1716       }
1717       break;
1718
1719     case 'a':
1720       {
1721         int jalx = l & 0x400;
1722
1723         if (! use_extend)
1724           extend = 0;
1725         l = ((l & 0x1f) << 23) | ((l & 0x3e0) << 13) | (extend << 2);
1726         if (!jalx && info->flavour == bfd_target_unknown_flavour)
1727           /* For gdb disassembler, maintain odd address.  */
1728           l |= 1;
1729       }
1730       info->target = ((memaddr + 4) & ~(bfd_vma) 0x0fffffff) | l;
1731       (*info->print_address_func) (info->target, info);
1732       info->insn_type = dis_jsr;
1733       info->branch_delay_insns = 1;
1734       break;
1735
1736     case 'l':
1737     case 'L':
1738       {
1739         int need_comma, amask, smask;
1740
1741         need_comma = 0;
1742
1743         l = (l >> MIPS16OP_SH_IMM6) & MIPS16OP_MASK_IMM6;
1744
1745         amask = (l >> 3) & 7;
1746
1747         if (amask > 0 && amask < 5)
1748           {
1749             (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[4]);
1750             if (amask > 1)
1751               (*info->fprintf_func) (info->stream, "-%s",
1752                                      mips_gpr_names[amask + 3]);
1753             need_comma = 1;
1754           }
1755
1756         smask = (l >> 1) & 3;
1757         if (smask == 3)
1758           {
1759             (*info->fprintf_func) (info->stream, "%s??",
1760                                    need_comma ? "," : "");
1761             need_comma = 1;
1762           }
1763         else if (smask > 0)
1764           {
1765             (*info->fprintf_func) (info->stream, "%s%s",
1766                                    need_comma ? "," : "",
1767                                    mips_gpr_names[16]);
1768             if (smask > 1)
1769               (*info->fprintf_func) (info->stream, "-%s",
1770                                      mips_gpr_names[smask + 15]);
1771             need_comma = 1;
1772           }
1773
1774         if (l & 1)
1775           {
1776             (*info->fprintf_func) (info->stream, "%s%s",
1777                                    need_comma ? "," : "",
1778                                    mips_gpr_names[31]);
1779             need_comma = 1;
1780           }
1781
1782         if (amask == 5 || amask == 6)
1783           {
1784             (*info->fprintf_func) (info->stream, "%s$f0",
1785                                    need_comma ? "," : "");
1786             if (amask == 6)
1787               (*info->fprintf_func) (info->stream, "-$f1");
1788           }
1789       }
1790       break;
1791
1792     case 'm':
1793     case 'M':
1794       /* MIPS16e save/restore.  */
1795       {
1796       int need_comma = 0;
1797       int amask, args, statics;
1798       int nsreg, smask;
1799       int framesz;
1800       int i, j;
1801
1802       l = l & 0x7f;
1803       if (use_extend)
1804         l |= extend << 16;
1805
1806       amask = (l >> 16) & 0xf;
1807       if (amask == MIPS16_ALL_ARGS)
1808         {
1809           args = 4;
1810           statics = 0;
1811         }
1812       else if (amask == MIPS16_ALL_STATICS)
1813         {
1814           args = 0;
1815           statics = 4;
1816         }
1817       else
1818         {
1819           args = amask >> 2;
1820           statics = amask & 3;
1821         }
1822
1823       if (args > 0) {
1824           (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[4]);
1825           if (args > 1)
1826             (*info->fprintf_func) (info->stream, "-%s",
1827                                    mips_gpr_names[4 + args - 1]);
1828           need_comma = 1;
1829       }
1830
1831       framesz = (((l >> 16) & 0xf0) | (l & 0x0f)) * 8;
1832       if (framesz == 0 && !use_extend)
1833         framesz = 128;
1834
1835       (*info->fprintf_func) (info->stream, "%s%d",
1836                              need_comma ? "," : "",
1837                              framesz);
1838
1839       if (l & 0x40)                   /* $ra */
1840         (*info->fprintf_func) (info->stream, ",%s", mips_gpr_names[31]);
1841
1842       nsreg = (l >> 24) & 0x7;
1843       smask = 0;
1844       if (l & 0x20)                   /* $s0 */
1845         smask |= 1 << 0;
1846       if (l & 0x10)                   /* $s1 */
1847         smask |= 1 << 1;
1848       if (nsreg > 0)                  /* $s2-$s8 */
1849         smask |= ((1 << nsreg) - 1) << 2;
1850
1851       /* Find first set static reg bit.  */
1852       for (i = 0; i < 9; i++)
1853         {
1854           if (smask & (1 << i))
1855             {
1856               (*info->fprintf_func) (info->stream, ",%s",
1857                                      mips_gpr_names[i == 8 ? 30 : (16 + i)]);
1858               /* Skip over string of set bits.  */
1859               for (j = i; smask & (2 << j); j++)
1860                 continue;
1861               if (j > i)
1862                 (*info->fprintf_func) (info->stream, "-%s",
1863                                        mips_gpr_names[j == 8 ? 30 : (16 + j)]);
1864               i = j + 1;
1865             }
1866         }
1867
1868       /* Statics $ax - $a3.  */
1869       if (statics == 1)
1870         (*info->fprintf_func) (info->stream, ",%s", mips_gpr_names[7]);
1871       else if (statics > 0)
1872         (*info->fprintf_func) (info->stream, ",%s-%s",
1873                                mips_gpr_names[7 - statics + 1],
1874                                mips_gpr_names[7]);
1875       }
1876       break;
1877
1878     default:
1879       /* xgettext:c-format */
1880       (*info->fprintf_func)
1881         (info->stream,
1882          _("# internal disassembler error, unrecognised modifier (%c)"),
1883          type);
1884       abort ();
1885     }
1886 }
1887
1888 /* Disassemble mips16 instructions.  */
1889
1890 static int
1891 print_insn_mips16 (bfd_vma memaddr, struct disassemble_info *info)
1892 {
1893   int status;
1894   bfd_byte buffer[2];
1895   int length;
1896   int insn;
1897   bfd_boolean use_extend;
1898   int extend = 0;
1899   const struct mips_opcode *op, *opend;
1900
1901   info->bytes_per_chunk = 2;
1902   info->display_endian = info->endian;
1903   info->insn_info_valid = 1;
1904   info->branch_delay_insns = 0;
1905   info->data_size = 0;
1906   info->insn_type = dis_nonbranch;
1907   info->target = 0;
1908   info->target2 = 0;
1909
1910   status = (*info->read_memory_func) (memaddr, buffer, 2, info);
1911   if (status != 0)
1912     {
1913       (*info->memory_error_func) (status, memaddr, info);
1914       return -1;
1915     }
1916
1917   length = 2;
1918
1919   if (info->endian == BFD_ENDIAN_BIG)
1920     insn = bfd_getb16 (buffer);
1921   else
1922     insn = bfd_getl16 (buffer);
1923
1924   /* Handle the extend opcode specially.  */
1925   use_extend = FALSE;
1926   if ((insn & 0xf800) == 0xf000)
1927     {
1928       use_extend = TRUE;
1929       extend = insn & 0x7ff;
1930
1931       memaddr += 2;
1932
1933       status = (*info->read_memory_func) (memaddr, buffer, 2, info);
1934       if (status != 0)
1935         {
1936           (*info->fprintf_func) (info->stream, "extend 0x%x",
1937                                  (unsigned int) extend);
1938           (*info->memory_error_func) (status, memaddr, info);
1939           return -1;
1940         }
1941
1942       if (info->endian == BFD_ENDIAN_BIG)
1943         insn = bfd_getb16 (buffer);
1944       else
1945         insn = bfd_getl16 (buffer);
1946
1947       /* Check for an extend opcode followed by an extend opcode.  */
1948       if ((insn & 0xf800) == 0xf000)
1949         {
1950           (*info->fprintf_func) (info->stream, "extend 0x%x",
1951                                  (unsigned int) extend);
1952           info->insn_type = dis_noninsn;
1953           return length;
1954         }
1955
1956       length += 2;
1957     }
1958
1959   /* FIXME: Should probably use a hash table on the major opcode here.  */
1960
1961   opend = mips16_opcodes + bfd_mips16_num_opcodes;
1962   for (op = mips16_opcodes; op < opend; op++)
1963     {
1964       if (op->pinfo != INSN_MACRO
1965           && !(no_aliases && (op->pinfo2 & INSN2_ALIAS))
1966           && (insn & op->mask) == op->match)
1967         {
1968           const char *s;
1969
1970           if (strchr (op->args, 'a') != NULL)
1971             {
1972               if (use_extend)
1973                 {
1974                   (*info->fprintf_func) (info->stream, "extend 0x%x",
1975                                          (unsigned int) extend);
1976                   info->insn_type = dis_noninsn;
1977                   return length - 2;
1978                 }
1979
1980               use_extend = FALSE;
1981
1982               memaddr += 2;
1983
1984               status = (*info->read_memory_func) (memaddr, buffer, 2,
1985                                                   info);
1986               if (status == 0)
1987                 {
1988                   use_extend = TRUE;
1989                   if (info->endian == BFD_ENDIAN_BIG)
1990                     extend = bfd_getb16 (buffer);
1991                   else
1992                     extend = bfd_getl16 (buffer);
1993                   length += 2;
1994                 }
1995             }
1996
1997           (*info->fprintf_func) (info->stream, "%s", op->name);
1998           if (op->args[0] != '\0')
1999             (*info->fprintf_func) (info->stream, "\t");
2000
2001           for (s = op->args; *s != '\0'; s++)
2002             {
2003               if (*s == ','
2004                   && s[1] == 'w'
2005                   && (((insn >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX)
2006                       == ((insn >> MIPS16OP_SH_RY) & MIPS16OP_MASK_RY)))
2007                 {
2008                   /* Skip the register and the comma.  */
2009                   ++s;
2010                   continue;
2011                 }
2012               if (*s == ','
2013                   && s[1] == 'v'
2014                   && (((insn >> MIPS16OP_SH_RZ) & MIPS16OP_MASK_RZ)
2015                       == ((insn >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX)))
2016                 {
2017                   /* Skip the register and the comma.  */
2018                   ++s;
2019                   continue;
2020                 }
2021               print_mips16_insn_arg (*s, op, insn, use_extend, extend, memaddr,
2022                                      info);
2023             }
2024
2025           if ((op->pinfo & INSN_UNCOND_BRANCH_DELAY) != 0)
2026             {
2027               info->branch_delay_insns = 1;
2028               if (info->insn_type != dis_jsr)
2029                 info->insn_type = dis_branch;
2030             }
2031
2032           return length;
2033         }
2034     }
2035
2036   if (use_extend)
2037     (*info->fprintf_func) (info->stream, "0x%x", extend | 0xf000);
2038   (*info->fprintf_func) (info->stream, "0x%x", insn);
2039   info->insn_type = dis_noninsn;
2040
2041   return length;
2042 }
2043
2044 /* In an environment where we do not know the symbol type of the
2045    instruction we are forced to assume that the low order bit of the
2046    instructions' address may mark it as a mips16 instruction.  If we
2047    are single stepping, or the pc is within the disassembled function,
2048    this works.  Otherwise, we need a clue.  Sometimes.  */
2049
2050 static int
2051 _print_insn_mips (bfd_vma memaddr,
2052                   struct disassemble_info *info,
2053                   enum bfd_endian endianness)
2054 {
2055   bfd_byte buffer[INSNLEN];
2056   int status;
2057
2058   set_default_mips_dis_options (info);
2059   parse_mips_dis_options (info->disassembler_options);
2060
2061 #if 1
2062   /* FIXME: If odd address, this is CLEARLY a mips 16 instruction.  */
2063   /* Only a few tools will work this way.  */
2064   if (memaddr & 0x01)
2065     return print_insn_mips16 (memaddr, info);
2066 #endif
2067
2068 #if SYMTAB_AVAILABLE
2069   if (info->mach == bfd_mach_mips16
2070       || (info->symbols != NULL
2071           && bfd_asymbol_flavour (*info->symbols) == bfd_target_elf_flavour
2072           && ELF_ST_IS_MIPS16 ((*(elf_symbol_type **) info->symbols)
2073                                ->internal_elf_sym.st_other)))
2074     return print_insn_mips16 (memaddr, info);
2075 #endif
2076
2077   status = (*info->read_memory_func) (memaddr, buffer, INSNLEN, info);
2078   if (status == 0)
2079     {
2080       unsigned long insn;
2081
2082       if (endianness == BFD_ENDIAN_BIG)
2083         insn = (unsigned long) bfd_getb32 (buffer);
2084       else
2085         insn = (unsigned long) bfd_getl32 (buffer);
2086
2087       return print_insn_mips (memaddr, insn, info);
2088     }
2089   else
2090     {
2091       (*info->memory_error_func) (status, memaddr, info);
2092       return -1;
2093     }
2094 }
2095
2096 int
2097 print_insn_big_mips (bfd_vma memaddr, struct disassemble_info *info)
2098 {
2099   return _print_insn_mips (memaddr, info, BFD_ENDIAN_BIG);
2100 }
2101
2102 int
2103 print_insn_little_mips (bfd_vma memaddr, struct disassemble_info *info)
2104 {
2105   return _print_insn_mips (memaddr, info, BFD_ENDIAN_LITTLE);
2106 }
2107 \f
2108 void
2109 print_mips_disassembler_options (FILE *stream)
2110 {
2111   unsigned int i;
2112
2113   fprintf (stream, _("\n\
2114 The following MIPS specific disassembler options are supported for use\n\
2115 with the -M switch (multiple options should be separated by commas):\n"));
2116
2117   fprintf (stream, _("\n\
2118   gpr-names=ABI            Print GPR names according to  specified ABI.\n\
2119                            Default: based on binary being disassembled.\n"));
2120
2121   fprintf (stream, _("\n\
2122   fpr-names=ABI            Print FPR names according to specified ABI.\n\
2123                            Default: numeric.\n"));
2124
2125   fprintf (stream, _("\n\
2126   cp0-names=ARCH           Print CP0 register names according to\n\
2127                            specified architecture.\n\
2128                            Default: based on binary being disassembled.\n"));
2129
2130   fprintf (stream, _("\n\
2131   hwr-names=ARCH           Print HWR names according to specified \n\
2132                            architecture.\n\
2133                            Default: based on binary being disassembled.\n"));
2134
2135   fprintf (stream, _("\n\
2136   reg-names=ABI            Print GPR and FPR names according to\n\
2137                            specified ABI.\n"));
2138
2139   fprintf (stream, _("\n\
2140   reg-names=ARCH           Print CP0 register and HWR names according to\n\
2141                            specified architecture.\n"));
2142
2143   fprintf (stream, _("\n\
2144   For the options above, the following values are supported for \"ABI\":\n\
2145    "));
2146   for (i = 0; i < ARRAY_SIZE (mips_abi_choices); i++)
2147     fprintf (stream, " %s", mips_abi_choices[i].name);
2148   fprintf (stream, _("\n"));
2149
2150   fprintf (stream, _("\n\
2151   For the options above, The following values are supported for \"ARCH\":\n\
2152    "));
2153   for (i = 0; i < ARRAY_SIZE (mips_arch_choices); i++)
2154     if (*mips_arch_choices[i].name != '\0')
2155       fprintf (stream, " %s", mips_arch_choices[i].name);
2156   fprintf (stream, _("\n"));
2157
2158   fprintf (stream, _("\n"));
2159 }